tech/sendico
2
0
Fork 0
Code Issues 30 Pull Requests Actions Packages Projects Releases Wiki Activity

outbox for gateways

Browse Source
This commit is contained in:
Stephan D
2026-02-18 01:35:28 +01:00
parent 974caf286c
commit 69531cee73
221 changed files with 12172 additions and 782 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
api/ledger/config.dev.yml
View File

@@ -34,6 +34,12 @@ messaging:
max_reconnects: 10
reconnect_wait: 5
buffer_size: 1024
# Optional: remove this block to use package defaults.
reliable_publisher:
enabled: true
batch_size: 100
poll_interval_seconds: 1
max_attempts: 5
fees:
address: "dev-billing-fees:50060"

6
api/ledger/config.yml
View File

@@ -34,6 +34,12 @@ messaging:
max_reconnects: 10
reconnect_wait: 5
buffer_size: 1024
# Optional: remove this block to use package defaults.
reliable_publisher:
enabled: true
batch_size: 100
poll_interval_seconds: 1
max_attempts: 5
fees:
address: "sendico_billing_fees:50060"

4
api/ledger/go.mod
View File

@@ -1,6 +1,6 @@
module github.com/tech/sendico/ledger
go 1.24.0
go 1.25.0
replace github.com/tech/sendico/pkg => ../pkg
@@ -49,5 +49,5 @@ require (
golang.org/x/sync v0.19.0 // indirect
golang.org/x/sys v0.41.0 // indirect
golang.org/x/text v0.34.0 // indirect
google.golang.org/genproto/googleapis/rpc v0.0.0-20260209200024-4cfbd4190f57 // indirect
google.golang.org/genproto/googleapis/rpc v0.0.0-20260217215200-42d3e9bedb6d // indirect
)

4
api/ledger/go.sum
View File

@@ -210,8 +210,8 @@ golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk=
gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E=
google.golang.org/genproto/googleapis/rpc v0.0.0-20260209200024-4cfbd4190f57 h1:mWPCjDEyshlQYzBpMNHaEof6UX1PmHcaUODUywQ0uac=
google.golang.org/genproto/googleapis/rpc v0.0.0-20260209200024-4cfbd4190f57/go.mod h1:j9x/tPzZkyxcgEFkiKEEGxfvyumM01BEtsW8xzOahRQ=
google.golang.org/genproto/googleapis/rpc v0.0.0-20260217215200-42d3e9bedb6d h1:t/LOSXPJ9R0B6fnZNyALBRfZBH0Uy0gT+uR+SJ6syqQ=
google.golang.org/genproto/googleapis/rpc v0.0.0-20260217215200-42d3e9bedb6d/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8=
google.golang.org/grpc v1.79.1 h1:zGhSi45ODB9/p3VAawt9a+O/MULLl9dpizzNNpq7flY=
google.golang.org/grpc v1.79.1/go.mod h1:KmT0Kjez+0dde/v2j9vzwoAScgEPx/Bw1CYChhHLrHQ=
google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=

35
api/ledger/internal/model/outbox.go
View File

@@ -1,35 +0,0 @@
package ledger
import (
"time"
"github.com/tech/sendico/pkg/db/storable"
"github.com/tech/sendico/pkg/mservice"
)
// Delivery status enum
type OutboxStatus string
const (
OutboxPending OutboxStatus = "pending"
OutboxSent OutboxStatus = "sent"
OutboxFailed OutboxStatus = "failed" // terminal after max retries, or keep pending with NextAttemptAt=nil
)
type OutboxEvent struct {
storable.Base `bson:",inline" json:",inline"`
EventID string `bson:"eventId" json:"eventId"` // deterministic; use as NATS Msg-Id
Subject string `bson:"subject" json:"subject"` // NATS subject / stream routing key
Payload []byte `bson:"payload" json:"payload"` // JSON (or other) payload
Status OutboxStatus `bson:"status" json:"status"` // enum
Attempts int `bson:"attempts" json:"attempts"` // total tries
NextAttemptAt *time.Time `bson:"nextAttemptAt,omitempty" json:"nextAttemptAt,omitempty"` // for backoff scheduler
SentAt *time.Time `bson:"sentAt,omitempty" json:"sentAt,omitempty"`
LastError string `bson:"lastError,omitempty" json:"lastError,omitempty"` // brief reason of last failure
CorrelationRef string `bson:"correlationRef,omitempty" json:"correlationRef,omitempty"` // e.g., journalEntryRef or idempotencyKey
}
func (o *OutboxEvent) Collection() string {
return mservice.LedgerOutbox
}

9
api/ledger/internal/server/internal/serverimp.go
View File

@@ -120,7 +120,14 @@ func (i *Imp) Start() error {
if cfg.GRPC != nil {
invokeURI = cfg.GRPC.DiscoveryInvokeURI()
}
svc := ledger.NewService(logger, repo, producer, feesClient, feesTimeout, invokeURI)
msgSettings := map[string]any(nil)
if cfg.Messaging != nil {
msgSettings = cfg.Messaging.Settings
}
svc, err := ledger.NewService(logger, repo, producer, msgSettings, feesClient, feesTimeout, invokeURI)
if err != nil {
return nil, err
}
if err := svc.EnsureSystemAccounts(context.Background()); err != nil {
return nil, err
}

16
api/ledger/internal/service/ledger/account_status.go
View File

@@ -38,7 +38,7 @@ func (s *Service) blockAccountResponder(_ context.Context, req *ledgerv1.BlockAc
if err == storage.ErrAccountNotFound {
return nil, merrors.NoData("account not found")
}
logger.Warn("failed to get account for block", zap.Error(err))
logger.Warn("Failed to get account for block", zap.Error(err))
return nil, merrors.Internal("failed to get account")
}
@@ -61,17 +61,17 @@ func (s *Service) blockAccountResponder(_ context.Context, req *ledgerv1.BlockAc
}
if account.Status == pmodel.LedgerAccountStatusFrozen {
logger.Debug("account already frozen", mzap.AccRef(accountRef))
logger.Debug("Account already frozen", mzap.AccRef(accountRef))
return &ledgerv1.BlockAccountResponse{Account: toProtoAccount(account)}, nil
}
if err := s.storage.Accounts().UpdateStatus(ctx, accountRef, pmodel.LedgerAccountStatusFrozen); err != nil {
logger.Warn("failed to freeze account", zap.Error(err))
logger.Warn("Failed to freeze account", zap.Error(err))
return nil, merrors.Internal("failed to block account")
}
account.Status = pmodel.LedgerAccountStatusFrozen
logger.Info("account blocked (frozen)", mzap.AccRef(accountRef))
logger.Info("Account blocked (frozen)", mzap.AccRef(accountRef))
return &ledgerv1.BlockAccountResponse{Account: toProtoAccount(account)}, nil
}
}
@@ -101,7 +101,7 @@ func (s *Service) unblockAccountResponder(_ context.Context, req *ledgerv1.Unblo
if err == storage.ErrAccountNotFound {
return nil, merrors.NoData("account not found")
}
logger.Warn("failed to get account for unblock", zap.Error(err))
logger.Warn("Failed to get account for unblock", zap.Error(err))
return nil, merrors.Internal("failed to get account")
}
@@ -124,17 +124,17 @@ func (s *Service) unblockAccountResponder(_ context.Context, req *ledgerv1.Unblo
}
if account.Status == pmodel.LedgerAccountStatusActive {
logger.Debug("account already active", mzap.AccRef(accountRef))
logger.Debug("Account already active", mzap.AccRef(accountRef))
return &ledgerv1.UnblockAccountResponse{Account: toProtoAccount(account)}, nil
}
if err := s.storage.Accounts().UpdateStatus(ctx, accountRef, pmodel.LedgerAccountStatusActive); err != nil {
logger.Warn("failed to activate account", zap.Error(err))
logger.Warn("Failed to activate account", zap.Error(err))
return nil, merrors.Internal("failed to unblock account")
}
account.Status = pmodel.LedgerAccountStatusActive
logger.Info("account unblocked (active)", mzap.AccRef(accountRef))
logger.Info("Account unblocked (active)", mzap.AccRef(accountRef))
return &ledgerv1.UnblockAccountResponse{Account: toProtoAccount(account)}, nil
}
}

2
api/ledger/internal/service/ledger/list_accounts.go
View File

@@ -48,7 +48,7 @@ func (s *Service) listAccountsResponder(_ context.Context, req *ledgerv1.ListAcc
// No pagination requested; return all accounts for the organization.
accounts, err := s.storage.Accounts().ListByOrganization(ctx, orgRef, filter, 0, 0)
if err != nil {
s.logger.Warn("failed to list ledger accounts", zap.Error(err), mzap.ObjRef("organization_ref", orgRef))
s.logger.Warn("Failed to list ledger accounts", zap.Error(err), mzap.ObjRef("organization_ref", orgRef))
return nil, err
}

207
api/ledger/internal/service/ledger/outbox_publisher.go
View File

@@ -1,207 +0,0 @@
package ledger
import (
"context"
"encoding/json"
"errors"
"time"
"github.com/tech/sendico/ledger/storage"
ledgerModel "github.com/tech/sendico/ledger/storage/model"
"github.com/tech/sendico/pkg/merrors"
pmessaging "github.com/tech/sendico/pkg/messaging"
me "github.com/tech/sendico/pkg/messaging/envelope"
"github.com/tech/sendico/pkg/mlogger"
domainmodel "github.com/tech/sendico/pkg/model"
notification "github.com/tech/sendico/pkg/model/notification"
"github.com/tech/sendico/pkg/mservice"
"go.uber.org/zap"
)
const (
defaultOutboxBatchSize = 100
defaultOutboxPollInterval = time.Second
maxOutboxDeliveryAttempts = 5
outboxPublisherSender = "ledger.outbox.publisher"
)
type outboxPublisher struct {
logger mlogger.Logger
store storage.OutboxStore
producer pmessaging.Producer
batchSize int
pollInterval time.Duration
}
func newOutboxPublisher(logger mlogger.Logger, store storage.OutboxStore, producer pmessaging.Producer) *outboxPublisher {
return &outboxPublisher{
logger: logger.Named("outbox.publisher"),
store: store,
producer: producer,
batchSize: defaultOutboxBatchSize,
pollInterval: defaultOutboxPollInterval,
}
}
func (p *outboxPublisher) run(ctx context.Context) {
p.logger.Info("started")
defer p.logger.Info("stopped")
for {
if ctx.Err() != nil {
return
}
processed, err := p.dispatchPending(ctx)
if err != nil && !errors.Is(err, context.Canceled) {
p.logger.Warn("failed to dispatch ledger outbox events", zap.Error(err))
}
if processed > 0 {
p.logger.Debug("dispatched ledger outbox events",
zap.Int("count", processed),
zap.Int("batch_size", p.batchSize))
}
if ctx.Err() != nil {
return
}
if processed == 0 {
select {
case <-ctx.Done():
return
case <-time.After(p.pollInterval):
}
}
}
}
func (p *outboxPublisher) dispatchPending(ctx context.Context) (int, error) {
if p.store == nil || p.producer == nil {
return 0, nil
}
events, err := p.store.ListPending(ctx, p.batchSize)
if err != nil {
return 0, err
}
for _, event := range events {
if ctx.Err() != nil {
return len(events), ctx.Err()
}
if err := p.publishEvent(ctx, event); err != nil {
if errors.Is(err, context.Canceled) {
return len(events), err
}
p.logger.Warn("failed to publish outbox event",
zap.Error(err),
zap.String("eventId", event.EventID),
zap.String("subject", event.Subject),
zap.String("organizationRef", event.OrganizationRef.Hex()),
zap.Int("attempts", event.Attempts))
p.handleFailure(ctx, event)
continue
}
if err := p.markSent(ctx, event); err != nil {
if errors.Is(err, context.Canceled) {
return len(events), err
}
p.logger.Warn("failed to mark outbox event as sent",
zap.Error(err),
zap.String("eventId", event.EventID),
zap.String("subject", event.Subject),
zap.String("organizationRef", event.OrganizationRef.Hex()))
} else {
p.logger.Debug("outbox event marked sent",
zap.String("eventId", event.EventID),
zap.String("subject", event.Subject),
zap.String("organizationRef", event.OrganizationRef.Hex()))
}
}
return len(events), nil
}
func (p *outboxPublisher) publishEvent(_ context.Context, event *ledgerModel.OutboxEvent) error {
docID := event.GetID()
if docID == nil || docID.IsZero() {
return merrors.InvalidArgument("outbox event missing identifier")
}
payload, err := p.wrapPayload(event)
if err != nil {
return err
}
env := me.CreateEnvelope(outboxPublisherSender, domainmodel.NewNotification(mservice.LedgerOutbox, notification.NASent))
if _, err = env.Wrap(payload); err != nil {
return err
}
return p.producer.SendMessage(env)
}
func (p *outboxPublisher) wrapPayload(event *ledgerModel.OutboxEvent) ([]byte, error) {
message := ledgerOutboxMessage{
EventID: event.EventID,
Subject: event.Subject,
Payload: json.RawMessage(event.Payload),
Attempts: event.Attempts,
OrganizationRef: event.OrganizationRef.Hex(),
CreatedAt: event.CreatedAt,
}
return json.Marshal(message)
}
func (p *outboxPublisher) markSent(ctx context.Context, event *ledgerModel.OutboxEvent) error {
eventRef := event.GetID()
if eventRef == nil || eventRef.IsZero() {
return merrors.InvalidArgument("outbox event missing identifier")
}
return p.store.MarkSent(ctx, *eventRef, time.Now().UTC())
}
func (p *outboxPublisher) handleFailure(ctx context.Context, event *ledgerModel.OutboxEvent) {
eventRef := event.GetID()
if eventRef == nil || eventRef.IsZero() {
p.logger.Warn("cannot record outbox failure: missing identifier", zap.String("eventId", event.EventID))
return
}
if err := p.store.IncrementAttempts(ctx, *eventRef); err != nil && !errors.Is(err, context.Canceled) {
p.logger.Warn("failed to increment outbox attempts",
zap.Error(err),
zap.String("eventId", event.EventID),
zap.String("subject", event.Subject),
zap.String("organizationRef", event.OrganizationRef.Hex()))
}
if event.Attempts+1 >= maxOutboxDeliveryAttempts {
if err := p.store.MarkFailed(ctx, *eventRef); err != nil && !errors.Is(err, context.Canceled) {
p.logger.Warn("failed to mark outbox event failed",
zap.Error(err),
zap.String("eventId", event.EventID),
zap.String("subject", event.Subject),
zap.String("organizationRef", event.OrganizationRef.Hex()),
zap.Int("attempts", event.Attempts+1))
} else {
p.logger.Warn("ledger outbox event marked as failed",
zap.String("eventId", event.EventID),
zap.String("subject", event.Subject),
zap.String("organizationRef", event.OrganizationRef.Hex()),
zap.Int("attempts", event.Attempts+1))
}
}
}
type ledgerOutboxMessage struct {
EventID string `json:"eventId"`
Subject string `json:"subject"`
Payload json.RawMessage `json:"payload"`
Attempts int `json:"attempts"`
OrganizationRef string `json:"organizationRef"`
CreatedAt time.Time `json:"createdAt"`
}

168
api/ledger/internal/service/ledger/outbox_reliable.go Normal file
View File

@@ -0,0 +1,168 @@
package ledger
import (
"context"
"encoding/json"
"strings"
"time"
"github.com/tech/sendico/ledger/storage"
"github.com/tech/sendico/ledger/storage/model"
pmessaging "github.com/tech/sendico/pkg/messaging"
me "github.com/tech/sendico/pkg/messaging/envelope"
pmessagingreliable "github.com/tech/sendico/pkg/messaging/reliable"
"github.com/tech/sendico/pkg/mlogger"
cfgmodel "github.com/tech/sendico/pkg/model"
domainmodel "github.com/tech/sendico/pkg/model"
notification "github.com/tech/sendico/pkg/model/notification"
"github.com/tech/sendico/pkg/mservice"
)
const (
outboxPublisherSender = "ledger.outbox.publisher"
)
type ledgerOutboxMessage struct {
EventID string `json:"eventId"`
Subject string `json:"subject"`
Payload json.RawMessage `json:"payload"`
Attempts int `json:"attempts"`
OrganizationRef string `json:"organizationRef"`
CreatedAt time.Time `json:"createdAt"`
}
type ledgerOutboxStoreAdapter struct {
store storage.OutboxStore
}
func newLedgerReliableProducer(logger mlogger.Logger, direct pmessaging.Producer, store storage.OutboxStore, messagingSettings cfgmodel.SettingsT) (*pmessagingreliable.ReliableProducer, pmessagingreliable.Settings, error) {
if store == nil {
return nil, pmessagingreliable.DefaultSettings(), nil
}
producer, settings, err := pmessagingreliable.NewReliableProducerFromConfig(logger, direct, &ledgerOutboxStoreAdapter{store: store}, messagingSettings,
pmessagingreliable.WithEnvelopeDecoder(ledgerOutboxDecoder),
)
if err != nil {
return nil, pmessagingreliable.Settings{}, err
}
return producer, settings, nil
}
func (a *ledgerOutboxStoreAdapter) Enqueue(ctx context.Context, msg pmessagingreliable.OutboxMessage) error {
if a == nil || a.store == nil {
return nil
}
event := &model.OutboxEvent{
EventID: strings.TrimSpace(msg.EventID),
Subject: strings.TrimSpace(msg.Subject),
Payload: append([]byte(nil), msg.Payload...),
Status: model.OutboxStatusPending,
Attempts: msg.Attempts,
}
if organizationRef := strings.TrimSpace(msg.OrganizationRef); organizationRef != "" {
orgRef, err := parseObjectID(organizationRef)
if err != nil {
return err
}
event.OrganizationRef = orgRef
}
return a.store.Create(ctx, event)
}
func (a *ledgerOutboxStoreAdapter) ListPending(ctx context.Context, limit int) ([]pmessagingreliable.OutboxMessage, error) {
if a == nil || a.store == nil {
return nil, nil
}
events, err := a.store.ListPending(ctx, limit)
if err != nil {
return nil, err
}
result := make([]pmessagingreliable.OutboxMessage, 0, len(events))
for _, event := range events {
if event == nil {
continue
}
reference := ""
if eventRef := event.GetID(); eventRef != nil && !eventRef.IsZero() {
reference = eventRef.Hex()
}
result = append(result, pmessagingreliable.OutboxMessage{
Reference: reference,
EventID: strings.TrimSpace(event.EventID),
Subject: strings.TrimSpace(event.Subject),
Payload: append([]byte(nil), event.Payload...),
Attempts: event.Attempts,
OrganizationRef: event.OrganizationRef.Hex(),
CreatedAt: event.CreatedAt,
})
}
return result, nil
}
func (a *ledgerOutboxStoreAdapter) MarkSent(ctx context.Context, reference string, sentAt time.Time) error {
if a == nil || a.store == nil {
return nil
}
eventRef, err := parseObjectID(strings.TrimSpace(reference))
if err != nil {
return err
}
return a.store.MarkSent(ctx, eventRef, sentAt)
}
func (a *ledgerOutboxStoreAdapter) MarkFailed(ctx context.Context, reference string) error {
if a == nil || a.store == nil {
return nil
}
eventRef, err := parseObjectID(strings.TrimSpace(reference))
if err != nil {
return err
}
return a.store.MarkFailed(ctx, eventRef)
}
func (a *ledgerOutboxStoreAdapter) IncrementAttempts(ctx context.Context, reference string) error {
if a == nil || a.store == nil {
return nil
}
eventRef, err := parseObjectID(strings.TrimSpace(reference))
if err != nil {
return err
}
return a.store.IncrementAttempts(ctx, eventRef)
}
func ledgerOutboxDecoder(record pmessagingreliable.OutboxMessage) (me.Envelope, error) {
env, err := me.Deserialize(record.Payload)
if err == nil {
return env, nil
}
if strings.TrimSpace(record.Subject) != ledgerOutboxSubject {
return nil, err
}
return buildLedgerOutboxEnvelope(record.EventID, record.Payload, record.Attempts, record.OrganizationRef, record.CreatedAt)
}
func buildLedgerOutboxEnvelope(eventID string, payload []byte, attempts int, organizationRef string, createdAt time.Time) (me.Envelope, error) {
msg := ledgerOutboxMessage{
EventID: strings.TrimSpace(eventID),
Subject: ledgerOutboxSubject,
Payload: append([]byte(nil), payload...),
Attempts: attempts,
OrganizationRef: strings.TrimSpace(organizationRef),
CreatedAt: createdAt,
}
body, err := json.Marshal(msg)
if err != nil {
return nil, err
}
env := me.CreateEnvelope(outboxPublisherSender, domainmodel.NewNotification(mservice.LedgerOutbox, notification.NASent))
if _, err = env.Wrap(body); err != nil {
return nil, err
}
return env, nil
}

53
api/ledger/internal/service/ledger/outbox_publisher_test.go → api/ledger/internal/service/ledger/outbox_reliable_test.go
View File

@@ -12,33 +12,35 @@ import (
"github.com/stretchr/testify/require"
"github.com/tech/sendico/ledger/storage/model"
me "github.com/tech/sendico/pkg/messaging/envelope"
pmessagingreliable "github.com/tech/sendico/pkg/messaging/reliable"
"go.mongodb.org/mongo-driver/v2/bson"
"go.uber.org/zap"
)
func TestOutboxPublisherDispatchSuccess(t *testing.T) {
func TestLedgerReliableProducerDispatchesLegacyOutboxRecords(t *testing.T) {
logger := zap.NewNop()
event := &model.OutboxEvent{
EventID: "entry-1",
Subject: "ledger.entry.posted",
Subject: ledgerOutboxSubject,
Payload: []byte(`{"journalEntryRef":"abc123"}`),
Attempts: 0,
}
event.SetID(bson.NewObjectID())
event.OrganizationRef = bson.NewObjectID()
store := &recordingOutboxStore{
store := &recordingLedgerOutboxStore{
pending: []*model.OutboxEvent{event},
}
producer := &stubProducer{}
publisher := newOutboxPublisher(logger, store, producer)
direct := &stubDirectProducer{}
producer, _, err := newLedgerReliableProducer(logger, direct, store, nil)
require.NoError(t, err)
processed, err := publisher.dispatchPending(context.Background())
processed, err := producer.DispatchPending(context.Background())
require.NoError(t, err)
assert.Equal(t, 1, processed)
require.Len(t, producer.envelopes, 1)
env := producer.envelopes[0]
require.Len(t, direct.envelopes, 1)
env := direct.envelopes[0]
assert.Equal(t, outboxPublisherSender, env.GetSender())
assert.Equal(t, "ledger_outbox_sent", env.GetSignature().ToString())
@@ -47,6 +49,7 @@ func TestOutboxPublisherDispatchSuccess(t *testing.T) {
assert.Equal(t, event.EventID, message.EventID)
assert.Equal(t, event.Subject, message.Subject)
assert.Equal(t, event.OrganizationRef.Hex(), message.OrganizationRef)
assert.JSONEq(t, `{"journalEntryRef":"abc123"}`, string(message.Payload))
require.Len(t, store.markedSent, 1)
assert.Equal(t, *event.GetID(), store.markedSent[0])
@@ -54,37 +57,36 @@ func TestOutboxPublisherDispatchSuccess(t *testing.T) {
assert.Empty(t, store.incremented)
}
func TestOutboxPublisherDispatchFailureMarksAttempts(t *testing.T) {
func TestLedgerReliableProducerMarksFailedOnDispatchError(t *testing.T) {
logger := zap.NewNop()
event := &model.OutboxEvent{
EventID: "entry-2",
Subject: "ledger.entry.posted",
Subject: ledgerOutboxSubject,
Payload: []byte(`{"journalEntryRef":"xyz789"}`),
Attempts: maxOutboxDeliveryAttempts - 1,
Attempts: pmessagingreliable.DefaultSettings().MaxAttempts - 1,
}
event.SetID(bson.NewObjectID())
event.OrganizationRef = bson.NewObjectID()
store := &recordingOutboxStore{
store := &recordingLedgerOutboxStore{
pending: []*model.OutboxEvent{event},
}
producer := &stubProducer{err: errors.New("publish failed")}
publisher := newOutboxPublisher(logger, store, producer)
direct := &stubDirectProducer{err: errors.New("publish failed")}
producer, _, err := newLedgerReliableProducer(logger, direct, store, nil)
require.NoError(t, err)
processed, err := publisher.dispatchPending(context.Background())
processed, err := producer.DispatchPending(context.Background())
require.NoError(t, err)
assert.Equal(t, 1, processed)
require.Len(t, store.incremented, 1)
assert.Equal(t, *event.GetID(), store.incremented[0])
require.Len(t, store.markedFailed, 1)
assert.Equal(t, *event.GetID(), store.markedFailed[0])
assert.Empty(t, store.markedSent)
}
type recordingOutboxStore struct {
type recordingLedgerOutboxStore struct {
mu sync.Mutex
pending []*model.OutboxEvent
@@ -94,11 +96,11 @@ type recordingOutboxStore struct {
incremented []bson.ObjectID
}
func (s *recordingOutboxStore) Create(context.Context, *model.OutboxEvent) error {
func (s *recordingLedgerOutboxStore) Create(context.Context, *model.OutboxEvent) error {
return nil
}
func (s *recordingOutboxStore) ListPending(context.Context, int) ([]*model.OutboxEvent, error) {
func (s *recordingLedgerOutboxStore) ListPending(context.Context, int) ([]*model.OutboxEvent, error) {
s.mu.Lock()
defer s.mu.Unlock()
events := s.pending
@@ -106,35 +108,34 @@ func (s *recordingOutboxStore) ListPending(context.Context, int) ([]*model.Outbo
return events, nil
}
func (s *recordingOutboxStore) MarkSent(_ context.Context, eventRef bson.ObjectID, sentAt time.Time) error {
_ = sentAt
func (s *recordingLedgerOutboxStore) MarkSent(_ context.Context, eventRef bson.ObjectID, _ time.Time) error {
s.mu.Lock()
defer s.mu.Unlock()
s.markedSent = append(s.markedSent, eventRef)
return nil
}
func (s *recordingOutboxStore) MarkFailed(_ context.Context, eventRef bson.ObjectID) error {
func (s *recordingLedgerOutboxStore) MarkFailed(_ context.Context, eventRef bson.ObjectID) error {
s.mu.Lock()
defer s.mu.Unlock()
s.markedFailed = append(s.markedFailed, eventRef)
return nil
}
func (s *recordingOutboxStore) IncrementAttempts(_ context.Context, eventRef bson.ObjectID) error {
func (s *recordingLedgerOutboxStore) IncrementAttempts(_ context.Context, eventRef bson.ObjectID) error {
s.mu.Lock()
defer s.mu.Unlock()
s.incremented = append(s.incremented, eventRef)
return nil
}
type stubProducer struct {
type stubDirectProducer struct {
mu sync.Mutex
envelopes []me.Envelope
err error
}
func (p *stubProducer) SendMessage(env me.Envelope) error {
func (p *stubDirectProducer) SendMessage(env me.Envelope) error {
p.mu.Lock()
defer p.mu.Unlock()
p.envelopes = append(p.envelopes, env)

12
api/ledger/internal/service/ledger/posting.go
View File

@@ -66,7 +66,7 @@ func (s *Service) postCreditResponder(_ context.Context, req *ledgerv1.PostCredi
existingEntry, err := s.storage.JournalEntries().GetByIdempotencyKey(ctx, orgRef, req.IdempotencyKey)
if err == nil && existingEntry != nil {
recordDuplicateRequest("credit")
logger.Info("duplicate credit request (idempotency)",
logger.Info("Duplicate credit request (idempotency)",
zap.String("existingEntryID", existingEntry.GetID().Hex()))
return &ledgerv1.PostResponse{
JournalEntryRef: existingEntry.GetID().Hex(),
@@ -76,7 +76,7 @@ func (s *Service) postCreditResponder(_ context.Context, req *ledgerv1.PostCredi
}
if err != nil && err != storage.ErrJournalEntryNotFound {
recordJournalEntryError("credit", "idempotency_check_failed")
logger.Warn("failed to check idempotency", zap.Error(err))
logger.Warn("Failed to check idempotency", zap.Error(err))
return nil, merrors.Internal("failed to check idempotency")
}
@@ -99,7 +99,7 @@ func (s *Service) postCreditResponder(_ context.Context, req *ledgerv1.PostCredi
charges := req.Charges
if len(charges) == 0 {
if computed, err := s.quoteFeesForCredit(ctx, req); err != nil {
logger.Warn("failed to quote fees", zap.Error(err))
logger.Warn("Failed to quote fees", zap.Error(err))
} else if len(computed) > 0 {
charges = computed
}
@@ -133,7 +133,7 @@ func (s *Service) postCreditResponder(_ context.Context, req *ledgerv1.PostCredi
if err == storage.ErrAccountNotFound {
return nil, merrors.NoData(fmt.Sprintf("charges[%d]: account not found", i))
}
logger.Warn("failed to get charge account", zap.Error(err), zap.String("chargeAccountRef", chargeAccountRef.Hex()))
logger.Warn("Failed to get charge account", zap.Error(err), zap.String("chargeAccountRef", chargeAccountRef.Hex()))
return nil, merrors.Internal("failed to get charge account")
}
if err := validateAccountForOrg(chargeAccount, orgRef, charge.Money.Currency); err != nil {
@@ -199,7 +199,7 @@ func (s *Service) postCreditResponder(_ context.Context, req *ledgerv1.PostCredi
entry.OrganizationRef = orgRef
if err := s.storage.JournalEntries().Create(txCtx, entry); err != nil {
logger.Warn("failed to create journal entry", zap.Error(err))
logger.Warn("Failed to create journal entry", zap.Error(err))
return nil, merrors.Internal("failed to create journal entry")
}
@@ -217,7 +217,7 @@ func (s *Service) postCreditResponder(_ context.Context, req *ledgerv1.PostCredi
}
if err := s.storage.PostingLines().CreateMany(txCtx, postingLines); err != nil {
logger.Warn("failed to create posting lines", zap.Error(err))
logger.Warn("Failed to create posting lines", zap.Error(err))
return nil, merrors.Internal("failed to create posting lines")
}

12
api/ledger/internal/service/ledger/posting_debit.go
View File

@@ -64,7 +64,7 @@ func (s *Service) postDebitResponder(_ context.Context, req *ledgerv1.PostDebitR
existingEntry, err := s.storage.JournalEntries().GetByIdempotencyKey(ctx, orgRef, req.IdempotencyKey)
if err == nil && existingEntry != nil {
recordDuplicateRequest("debit")
logger.Info("duplicate debit request (idempotency)",
logger.Info("Duplicate debit request (idempotency)",
zap.String("existingEntryID", existingEntry.GetID().Hex()))
return &ledgerv1.PostResponse{
JournalEntryRef: existingEntry.GetID().Hex(),
@@ -73,7 +73,7 @@ func (s *Service) postDebitResponder(_ context.Context, req *ledgerv1.PostDebitR
}, nil
}
if err != nil && err != storage.ErrJournalEntryNotFound {
logger.Warn("failed to check idempotency", zap.Error(err))
logger.Warn("Failed to check idempotency", zap.Error(err))
return nil, merrors.Internal("failed to check idempotency")
}
@@ -96,7 +96,7 @@ func (s *Service) postDebitResponder(_ context.Context, req *ledgerv1.PostDebitR
charges := req.Charges
if len(charges) == 0 {
if computed, err := s.quoteFeesForDebit(ctx, req); err != nil {
logger.Warn("failed to quote fees", zap.Error(err))
logger.Warn("Failed to quote fees", zap.Error(err))
} else if len(computed) > 0 {
charges = computed
}
@@ -130,7 +130,7 @@ func (s *Service) postDebitResponder(_ context.Context, req *ledgerv1.PostDebitR
if err == storage.ErrAccountNotFound {
return nil, merrors.NoData(fmt.Sprintf("charges[%d]: account not found", i))
}
logger.Warn("failed to get charge account", zap.Error(err), zap.String("chargeAccountRef", chargeAccountRef.Hex()))
logger.Warn("Failed to get charge account", zap.Error(err), zap.String("chargeAccountRef", chargeAccountRef.Hex()))
return nil, merrors.Internal("failed to get charge account")
}
if err := validateAccountForOrg(chargeAccount, orgRef, charge.Money.Currency); err != nil {
@@ -196,7 +196,7 @@ func (s *Service) postDebitResponder(_ context.Context, req *ledgerv1.PostDebitR
entry.OrganizationRef = orgRef
if err := s.storage.JournalEntries().Create(txCtx, entry); err != nil {
logger.Warn("failed to create journal entry", zap.Error(err))
logger.Warn("Failed to create journal entry", zap.Error(err))
return nil, merrors.Internal("failed to create journal entry")
}
@@ -214,7 +214,7 @@ func (s *Service) postDebitResponder(_ context.Context, req *ledgerv1.PostDebitR
}
if err := s.storage.PostingLines().CreateMany(txCtx, postingLines); err != nil {
logger.Warn("failed to create posting lines", zap.Error(err))
logger.Warn("Failed to create posting lines", zap.Error(err))
return nil, merrors.Internal("failed to create posting lines")
}

24
api/ledger/internal/service/ledger/posting_external.go
View File

@@ -61,7 +61,7 @@ func (s *Service) postExternalCreditResponder(_ context.Context, req *ledgerv1.P
existingEntry, err := s.storage.JournalEntries().GetByIdempotencyKey(ctx, orgRef, req.IdempotencyKey)
if err == nil && existingEntry != nil {
recordDuplicateRequest("credit")
logger.Info("duplicate external credit request (idempotency)",
logger.Info("Duplicate external credit request (idempotency)",
zap.String("existingEntryID", existingEntry.GetID().Hex()))
return &ledgerv1.PostResponse{
JournalEntryRef: existingEntry.GetID().Hex(),
@@ -71,7 +71,7 @@ func (s *Service) postExternalCreditResponder(_ context.Context, req *ledgerv1.P
}
if err != nil && err != storage.ErrJournalEntryNotFound {
recordJournalEntryError("credit", "idempotency_check_failed")
logger.Warn("failed to check idempotency", zap.Error(err))
logger.Warn("Failed to check idempotency", zap.Error(err))
return nil, merrors.Internal("failed to check idempotency")
}
@@ -113,7 +113,7 @@ func (s *Service) postExternalCreditResponder(_ context.Context, req *ledgerv1.P
charges := req.Charges
if len(charges) == 0 {
if computed, err := s.quoteFeesForCredit(ctx, req); err != nil {
logger.Warn("failed to quote fees", zap.Error(err))
logger.Warn("Failed to quote fees", zap.Error(err))
} else if len(computed) > 0 {
charges = computed
}
@@ -147,7 +147,7 @@ func (s *Service) postExternalCreditResponder(_ context.Context, req *ledgerv1.P
if err == storage.ErrAccountNotFound {
return nil, merrors.NoData(fmt.Sprintf("charges[%d]: account not found", i))
}
logger.Warn("failed to get charge account", zap.Error(err), zap.String("chargeAccountRef", chargeAccountRef.Hex()))
logger.Warn("Failed to get charge account", zap.Error(err), zap.String("chargeAccountRef", chargeAccountRef.Hex()))
return nil, merrors.Internal("failed to get charge account")
}
if err := validateAccountForOrg(chargeAccount, orgRef, charge.Money.Currency); err != nil {
@@ -202,7 +202,7 @@ func (s *Service) postExternalCreditResponder(_ context.Context, req *ledgerv1.P
entry.OrganizationRef = orgRef
if err := s.storage.JournalEntries().Create(txCtx, entry); err != nil {
logger.Warn("failed to create journal entry", zap.Error(err))
logger.Warn("Failed to create journal entry", zap.Error(err))
return nil, merrors.Internal("failed to create journal entry")
}
@@ -220,7 +220,7 @@ func (s *Service) postExternalCreditResponder(_ context.Context, req *ledgerv1.P
}
if err := s.storage.PostingLines().CreateMany(txCtx, postingLines); err != nil {
logger.Warn("failed to create posting lines", zap.Error(err))
logger.Warn("Failed to create posting lines", zap.Error(err))
return nil, merrors.Internal("failed to create posting lines")
}
@@ -294,7 +294,7 @@ func (s *Service) postExternalDebitResponder(_ context.Context, req *ledgerv1.Po
existingEntry, err := s.storage.JournalEntries().GetByIdempotencyKey(ctx, orgRef, req.IdempotencyKey)
if err == nil && existingEntry != nil {
recordDuplicateRequest("debit")
logger.Info("duplicate external debit request (idempotency)",
logger.Info("Duplicate external debit request (idempotency)",
zap.String("existingEntryID", existingEntry.GetID().Hex()))
return &ledgerv1.PostResponse{
JournalEntryRef: existingEntry.GetID().Hex(),
@@ -304,7 +304,7 @@ func (s *Service) postExternalDebitResponder(_ context.Context, req *ledgerv1.Po
}
if err != nil && err != storage.ErrJournalEntryNotFound {
recordJournalEntryError("debit", "idempotency_check_failed")
logger.Warn("failed to check idempotency", zap.Error(err))
logger.Warn("Failed to check idempotency", zap.Error(err))
return nil, merrors.Internal("failed to check idempotency")
}
@@ -346,7 +346,7 @@ func (s *Service) postExternalDebitResponder(_ context.Context, req *ledgerv1.Po
charges := req.Charges
if len(charges) == 0 {
if computed, err := s.quoteFeesForDebit(ctx, req); err != nil {
logger.Warn("failed to quote fees", zap.Error(err))
logger.Warn("Failed to quote fees", zap.Error(err))
} else if len(computed) > 0 {
charges = computed
}
@@ -380,7 +380,7 @@ func (s *Service) postExternalDebitResponder(_ context.Context, req *ledgerv1.Po
if err == storage.ErrAccountNotFound {
return nil, merrors.NoData(fmt.Sprintf("charges[%d]: account not found", i))
}
logger.Warn("failed to get charge account", zap.Error(err), zap.String("chargeAccountRef", chargeAccountRef.Hex()))
logger.Warn("Failed to get charge account", zap.Error(err), zap.String("chargeAccountRef", chargeAccountRef.Hex()))
return nil, merrors.Internal("failed to get charge account")
}
if err := validateAccountForOrg(chargeAccount, orgRef, charge.Money.Currency); err != nil {
@@ -435,7 +435,7 @@ func (s *Service) postExternalDebitResponder(_ context.Context, req *ledgerv1.Po
entry.OrganizationRef = orgRef
if err := s.storage.JournalEntries().Create(txCtx, entry); err != nil {
logger.Warn("failed to create journal entry", zap.Error(err))
logger.Warn("Failed to create journal entry", zap.Error(err))
return nil, merrors.Internal("failed to create journal entry")
}
@@ -453,7 +453,7 @@ func (s *Service) postExternalDebitResponder(_ context.Context, req *ledgerv1.Po
}
if err := s.storage.PostingLines().CreateMany(txCtx, postingLines); err != nil {
logger.Warn("failed to create posting lines", zap.Error(err))
logger.Warn("Failed to create posting lines", zap.Error(err))
return nil, merrors.Internal("failed to create posting lines")
}

14
api/ledger/internal/service/ledger/posting_fx.go
View File

@@ -77,7 +77,7 @@ func (s *Service) fxResponder(_ context.Context, req *ledgerv1.FXRequest) gsresp
existingEntry, err := s.storage.JournalEntries().GetByIdempotencyKey(ctx, orgRef, req.IdempotencyKey)
if err == nil && existingEntry != nil {
recordDuplicateRequest("fx")
logger.Info("duplicate FX request (idempotency)",
logger.Info("Duplicate FX request (idempotency)",
zap.String("existingEntryID", existingEntry.GetID().Hex()))
return &ledgerv1.PostResponse{
JournalEntryRef: existingEntry.GetID().Hex(),
@@ -86,7 +86,7 @@ func (s *Service) fxResponder(_ context.Context, req *ledgerv1.FXRequest) gsresp
}, nil
}
if err != nil && err != storage.ErrJournalEntryNotFound {
logger.Warn("failed to check idempotency", zap.Error(err))
logger.Warn("Failed to check idempotency", zap.Error(err))
return nil, merrors.Internal("failed to check idempotency")
}
@@ -96,7 +96,7 @@ func (s *Service) fxResponder(_ context.Context, req *ledgerv1.FXRequest) gsresp
if err == storage.ErrAccountNotFound {
return nil, merrors.NoData("from_account not found")
}
logger.Warn("failed to get from_account", zap.Error(err))
logger.Warn("Failed to get from_account", zap.Error(err))
return nil, merrors.Internal("failed to get from_account")
}
if err := validateAccountForOrg(fromAccount, orgRef, req.FromMoney.Currency); err != nil {
@@ -108,7 +108,7 @@ func (s *Service) fxResponder(_ context.Context, req *ledgerv1.FXRequest) gsresp
if err == storage.ErrAccountNotFound {
return nil, merrors.NoData("to_account not found")
}
logger.Warn("failed to get to_account", zap.Error(err))
logger.Warn("Failed to get to_account", zap.Error(err))
return nil, merrors.Internal("failed to get to_account")
}
if err := validateAccountForOrg(toAccount, orgRef, req.ToMoney.Currency); err != nil {
@@ -162,7 +162,7 @@ func (s *Service) fxResponder(_ context.Context, req *ledgerv1.FXRequest) gsresp
if err == storage.ErrAccountNotFound {
return nil, merrors.NoData(fmt.Sprintf("charges[%d]: account not found", i))
}
logger.Warn("failed to get FX charge account", zap.Error(err), zap.String("chargeAccountRef", chargeAccountRef.Hex()))
logger.Warn("Failed to get FX charge account", zap.Error(err), zap.String("chargeAccountRef", chargeAccountRef.Hex()))
return nil, merrors.Internal("failed to get charge account")
}
if err := validateAccountForOrg(chargeAccount, orgRef, charge.Money.Currency); err != nil {
@@ -210,7 +210,7 @@ func (s *Service) fxResponder(_ context.Context, req *ledgerv1.FXRequest) gsresp
entry.OrganizationRef = orgRef
if err := s.storage.JournalEntries().Create(txCtx, entry); err != nil {
logger.Warn("failed to create journal entry", zap.Error(err))
logger.Warn("Failed to create journal entry", zap.Error(err))
return nil, merrors.Internal("failed to create journal entry")
}
@@ -224,7 +224,7 @@ func (s *Service) fxResponder(_ context.Context, req *ledgerv1.FXRequest) gsresp
}
if err := s.storage.PostingLines().CreateMany(txCtx, postingLines); err != nil {
logger.Warn("failed to create posting lines", zap.Error(err))
logger.Warn("Failed to create posting lines", zap.Error(err))
return nil, merrors.Internal("failed to create posting lines")
}

37
api/ledger/internal/service/ledger/posting_support.go
View File

@@ -139,7 +139,7 @@ func (s *Service) resolveSettlementAccount(ctx context.Context, orgRef bson.Obje
if errors.Is(err, storage.ErrAccountNotFound) {
return nil, merrors.NoData("contra account not found")
}
s.logger.Warn("failed to load override contra account", zap.Error(err), zap.String("accountRef", overrideRef.Hex()))
s.logger.Warn("Failed to load override contra account", zap.Error(err), zap.String("accountRef", overrideRef.Hex()))
return nil, merrors.Internal("failed to load contra account")
}
if err := validateAccountForOrg(account, orgRef, currency); err != nil {
@@ -153,7 +153,7 @@ func (s *Service) resolveSettlementAccount(ctx context.Context, orgRef bson.Obje
if errors.Is(err, storage.ErrAccountNotFound) {
return nil, merrors.InvalidArgument("no default settlement account configured for currency")
}
s.logger.Warn("failed to resolve default settlement account",
s.logger.Warn("Failed to resolve default settlement account",
zap.Error(err),
mzap.ObjRef("organization_ref", orgRef),
zap.String("currency", currency))
@@ -197,13 +197,13 @@ func (s *Service) upsertBalances(ctx context.Context, lines []*model.PostingLine
for accountRef, delta := range balanceDeltas {
account := accounts[accountRef]
if account == nil {
s.logger.Warn("account cache missing for balance update", mzap.AccRef(accountRef))
s.logger.Warn("Account cache missing for balance update", mzap.AccRef(accountRef))
return merrors.Internal("account cache missing for balance update")
}
currentBalance, err := balancesStore.Get(ctx, accountRef)
if err != nil && !errors.Is(err, storage.ErrBalanceNotFound) {
s.logger.Warn("failed to fetch account balance",
s.logger.Warn("Failed to fetch account balance",
zap.Error(err),
mzap.AccRef(accountRef))
return merrors.Internal("failed to update balance")
@@ -238,7 +238,7 @@ func (s *Service) upsertBalances(ctx context.Context, lines []*model.PostingLine
}
if err := balancesStore.Upsert(ctx, newBalance); err != nil {
s.logger.Warn("failed to upsert account balance", zap.Error(err), mzap.AccRef(accountRef))
s.logger.Warn("Failed to upsert account balance", zap.Error(err), mzap.AccRef(accountRef))
return merrors.Internal("failed to update balance")
}
}
@@ -275,21 +275,26 @@ func (s *Service) enqueueOutbox(ctx context.Context, entry *model.JournalEntry,
body, err := json.Marshal(payload)
if err != nil {
s.logger.Warn("failed to marshal ledger outbox payload", zap.Error(err))
s.logger.Warn("Failed to marshal ledger outbox payload", zap.Error(err))
return merrors.Internal("failed to marshal ledger event")
}
event := &model.OutboxEvent{
EventID: entryID.Hex(),
Subject: ledgerOutboxSubject,
Payload: body,
Status: model.OutboxStatusPending,
Attempts: 0,
envelope, err := buildLedgerOutboxEnvelope(entryID.Hex(), body, 0, entry.OrganizationRef.Hex(), time.Now().UTC())
if err != nil {
s.logger.Warn("Failed to build ledger outbox envelope", zap.Error(err))
return merrors.Internal("failed to prepare ledger event envelope")
}
event.OrganizationRef = entry.OrganizationRef
if err := s.storage.Outbox().Create(ctx, event); err != nil {
s.logger.Warn("failed to enqueue ledger outbox event", zap.Error(err))
if err := s.startOutboxReliableProducer(); err != nil {
s.logger.Warn("Failed to initialise outbox reliable producer", zap.Error(err))
return merrors.Internal("failed to initialize reliable outbox")
}
if s.outbox.producer == nil {
s.logger.Warn("Failed to enqueue ledger outbox event: reliable producer not configured")
return merrors.Internal("failed to enqueue ledger event")
}
if err := s.outbox.producer.SendWithOutbox(ctx, envelope); err != nil {
s.logger.Warn("Failed to enqueue ledger outbox event", zap.Error(err))
return merrors.Internal("failed to enqueue ledger event")
}

16
api/ledger/internal/service/ledger/posting_support_test.go
View File

@@ -12,6 +12,7 @@ import (
"github.com/tech/sendico/ledger/storage"
"github.com/tech/sendico/ledger/storage/model"
"github.com/tech/sendico/pkg/merrors"
me "github.com/tech/sendico/pkg/messaging/envelope"
pmodel "github.com/tech/sendico/pkg/model"
"github.com/tech/sendico/pkg/model/account_role"
"go.mongodb.org/mongo-driver/v2/bson"
@@ -278,11 +279,20 @@ func TestEnqueueOutbox_CreatesEvent(t *testing.T) {
require.NoError(t, service.enqueueOutbox(ctx, entry, lines))
require.Len(t, producer.created, 1)
event := producer.created[0]
assert.Equal(t, entryID.Hex(), event.EventID)
assert.Equal(t, ledgerOutboxSubject, event.Subject)
assert.Equal(t, "ledger_outbox_sent", event.Subject)
envelope, err := me.Deserialize(event.Payload)
require.NoError(t, err)
assert.Equal(t, outboxPublisherSender, envelope.GetSender())
assert.Equal(t, "ledger_outbox_sent", envelope.GetSignature().ToString())
var wrapped ledgerOutboxMessage
require.NoError(t, json.Unmarshal(envelope.GetData(), &wrapped))
assert.Equal(t, entryID.Hex(), wrapped.EventID)
assert.Equal(t, ledgerOutboxSubject, wrapped.Subject)
var payload outboxJournalPayload
require.NoError(t, json.Unmarshal(event.Payload, &payload))
require.NoError(t, json.Unmarshal(wrapped.Payload, &payload))
assert.Equal(t, entryID.Hex(), payload.JournalEntryRef)
assert.Equal(t, "credit", payload.EntryType)
assert.Len(t, payload.Lines, 1)

10
api/ledger/internal/service/ledger/posting_transfer.go
View File

@@ -87,7 +87,7 @@ func (s *Service) transferResponder(_ context.Context, req *ledgerv1.TransferReq
existingEntry, err := s.storage.JournalEntries().GetByIdempotencyKey(ctx, orgRef, req.IdempotencyKey)
if err == nil && existingEntry != nil {
recordDuplicateRequest("transfer")
logger.Info("duplicate transfer request (idempotency)",
logger.Info("Duplicate transfer request (idempotency)",
zap.String("existingEntryID", existingEntry.GetID().Hex()))
return &ledgerv1.PostResponse{
JournalEntryRef: existingEntry.GetID().Hex(),
@@ -96,7 +96,7 @@ func (s *Service) transferResponder(_ context.Context, req *ledgerv1.TransferReq
}, nil
}
if err != nil && err != storage.ErrJournalEntryNotFound {
logger.Warn("failed to check idempotency", zap.Error(err))
logger.Warn("Failed to check idempotency", zap.Error(err))
return nil, merrors.Internal("failed to check idempotency")
}
@@ -172,7 +172,7 @@ func (s *Service) transferResponder(_ context.Context, req *ledgerv1.TransferReq
if err == storage.ErrAccountNotFound {
return nil, merrors.NoData(fmt.Sprintf("charges[%d]: account not found", i))
}
logger.Warn("failed to get charge account", zap.Error(err), zap.String("chargeAccountRef", chargeAccountRef.Hex()))
logger.Warn("Failed to get charge account", zap.Error(err), zap.String("chargeAccountRef", chargeAccountRef.Hex()))
return nil, merrors.Internal("failed to get charge account")
}
if err := validateAccountForOrg(chargeAccount, orgRef, charge.Money.Currency); err != nil {
@@ -208,7 +208,7 @@ func (s *Service) transferResponder(_ context.Context, req *ledgerv1.TransferReq
entry.OrganizationRef = orgRef
if err := s.storage.JournalEntries().Create(txCtx, entry); err != nil {
logger.Warn("failed to create journal entry", zap.Error(err))
logger.Warn("Failed to create journal entry", zap.Error(err))
return nil, merrors.Internal("failed to create journal entry")
}
@@ -226,7 +226,7 @@ func (s *Service) transferResponder(_ context.Context, req *ledgerv1.TransferReq
}
if err := s.storage.PostingLines().CreateMany(txCtx, postingLines); err != nil {
logger.Warn("failed to create posting lines", zap.Error(err))
logger.Warn("Failed to create posting lines", zap.Error(err))
return nil, merrors.Internal("failed to create posting lines")
}

18
api/ledger/internal/service/ledger/queries.go
View File

@@ -36,7 +36,7 @@ func (s *Service) getBalanceResponder(_ context.Context, req *ledgerv1.GetBalanc
if err == storage.ErrAccountNotFound {
return nil, merrors.NoData("account not found")
}
logger.Warn("failed to get account", zap.Error(err))
logger.Warn("Failed to get account", zap.Error(err))
return nil, merrors.Internal("failed to get account")
}
@@ -55,7 +55,7 @@ func (s *Service) getBalanceResponder(_ context.Context, req *ledgerv1.GetBalanc
LastUpdated: timestamppb.Now(),
}, nil
}
logger.Warn("failed to get balance", zap.Error(err))
logger.Warn("Failed to get balance", zap.Error(err))
return nil, merrors.Internal("failed to get balance")
}
@@ -92,14 +92,14 @@ func (s *Service) getJournalEntryResponder(_ context.Context, req *ledgerv1.GetE
if err == storage.ErrJournalEntryNotFound {
return nil, merrors.NoData("journal entry not found")
}
logger.Warn("failed to get journal entry", zap.Error(err))
logger.Warn("Failed to get journal entry", zap.Error(err))
return nil, merrors.Internal("failed to get journal entry")
}
// Get posting lines for this entry
lines, err := s.storage.PostingLines().ListByJournalEntry(ctx, entryRef)
if err != nil {
logger.Warn("failed to get posting lines", zap.Error(err))
logger.Warn("Failed to get posting lines", zap.Error(err))
return nil, merrors.Internal("failed to get posting lines")
}
@@ -151,7 +151,7 @@ func (s *Service) getStatementResponder(_ context.Context, req *ledgerv1.GetStat
if err == storage.ErrAccountNotFound {
return nil, merrors.NoData("account not found")
}
logger.Warn("failed to get account", zap.Error(err))
logger.Warn("Failed to get account", zap.Error(err))
return nil, merrors.Internal("failed to get account")
}
@@ -176,7 +176,7 @@ func (s *Service) getStatementResponder(_ context.Context, req *ledgerv1.GetStat
// Get posting lines for account
postingLines, err := s.storage.PostingLines().ListByAccount(ctx, accountRef, limit+1, offset)
if err != nil {
logger.Warn("failed to get posting lines", zap.Error(err))
logger.Warn("Failed to get posting lines", zap.Error(err))
return nil, merrors.Internal("failed to get posting lines")
}
@@ -196,20 +196,20 @@ func (s *Service) getStatementResponder(_ context.Context, req *ledgerv1.GetStat
for entryRefHex := range entryMap {
entryRef, err := parseObjectID(entryRefHex)
if err != nil {
s.logger.Warn("invalid journal entry ref in posting lines", zap.String("entry_ref", entryRefHex), zap.Error(err))
s.logger.Warn("Invalid journal entry ref in posting lines", zap.String("entry_ref", entryRefHex), zap.Error(err))
return nil, err
}
entry, err := s.storage.JournalEntries().Get(ctx, entryRef)
if err != nil {
logger.Warn("failed to get journal entry for statement", zap.Error(err), zap.String("entry_ref", entryRefHex))
logger.Warn("Failed to get journal entry for statement", zap.Error(err), zap.String("entry_ref", entryRefHex))
continue
}
// Get all lines for this entry
lines, err := s.storage.PostingLines().ListByJournalEntry(ctx, entryRef)
if err != nil {
logger.Warn("failed to get posting lines for entry", zap.Error(err), zap.String("entry_ref", entryRefHex))
logger.Warn("Failed to get posting lines for entry", zap.Error(err), zap.String("entry_ref", entryRefHex))
continue
}

45
api/ledger/internal/service/ledger/service.go
View File

@@ -23,6 +23,7 @@ import (
"github.com/tech/sendico/pkg/discovery"
"github.com/tech/sendico/pkg/merrors"
pmessaging "github.com/tech/sendico/pkg/messaging"
pmessagingreliable "github.com/tech/sendico/pkg/messaging/reliable"
"github.com/tech/sendico/pkg/mlogger"
pmodel "github.com/tech/sendico/pkg/model"
"github.com/tech/sendico/pkg/mservice"
@@ -44,14 +45,15 @@ type Service struct {
logger mlogger.Logger
storage storage.Repository
producer pmessaging.Producer
msgCfg pmodel.SettingsT
fees feesDependency
announcer *discovery.Announcer
invokeURI string
outbox struct {
once sync.Once
cancel context.CancelFunc
publisher *outboxPublisher
once sync.Once
cancel context.CancelFunc
producer *pmessagingreliable.ReliableProducer
}
systemAccounts struct {
@@ -70,7 +72,7 @@ func (f feesDependency) available() bool {
return f.client != nil
}
func NewService(logger mlogger.Logger, repo storage.Repository, prod pmessaging.Producer, feesClient feesv1.FeeEngineClient, feesTimeout time.Duration, invokeURI string) *Service {
func NewService(logger mlogger.Logger, repo storage.Repository, prod pmessaging.Producer, msgCfg pmodel.SettingsT, feesClient feesv1.FeeEngineClient, feesTimeout time.Duration, invokeURI string) (*Service, error) {
// Initialize Prometheus metrics
initMetrics()
@@ -78,6 +80,7 @@ func NewService(logger mlogger.Logger, repo storage.Repository, prod pmessaging.
logger: logger.Named("ledger"),
storage: repo,
producer: prod,
msgCfg: msgCfg,
invokeURI: strings.TrimSpace(invokeURI),
fees: feesDependency{
client: feesClient,
@@ -85,9 +88,11 @@ func NewService(logger mlogger.Logger, repo storage.Repository, prod pmessaging.
},
}
service.startOutboxPublisher()
if err := service.startOutboxReliableProducer(); err != nil {
return nil, err
}
service.startDiscoveryAnnouncer()
return service
return service, nil
}
func (s *Service) Register(router routers.GRPC) error {
@@ -405,23 +410,39 @@ func (s *Service) startDiscoveryAnnouncer() {
s.announcer.Start()
}
func (s *Service) startOutboxPublisher() {
if s.storage == nil || s.producer == nil {
return
func (s *Service) startOutboxReliableProducer() error {
if s.storage == nil {
return nil
}
var initErr error
s.outbox.once.Do(func() {
outboxStore := s.storage.Outbox()
if outboxStore == nil {
return
}
reliableProducer, settings, err := newLedgerReliableProducer(s.logger, s.producer, outboxStore, s.msgCfg)
if err != nil {
initErr = err
return
}
s.outbox.producer = reliableProducer
if s.outbox.producer == nil || s.producer == nil {
s.logger.Info("Outbox reliable publisher disabled",
zap.Bool("enabled", settings.Enabled))
return
}
s.logger.Info("Outbox reliable publisher configured",
zap.Bool("enabled", settings.Enabled),
zap.Int("batch_size", settings.BatchSize),
zap.Int("poll_interval_seconds", settings.PollIntervalSeconds),
zap.Int("max_attempts", settings.MaxAttempts))
ctx, cancel := context.WithCancel(context.Background())
s.outbox.cancel = cancel
s.outbox.publisher = newOutboxPublisher(s.logger, outboxStore, s.producer)
go s.outbox.publisher.run(ctx)
go s.outbox.producer.Run(ctx)
})
return initErr
}
// BlockAccount freezes a ledger account

24
api/ledger/storage/mongo/store/balances.go
View File

@@ -32,12 +32,12 @@ func NewBalances(logger mlogger.Logger, db *mongo.Database) (storage.BalancesSto
Unique: true,
}
if err := repo.CreateIndex(uniqueIndex); err != nil {
logger.Error("failed to ensure balances unique index", zap.Error(err))
logger.Error("Failed to ensure balances unique index", zap.Error(err))
return nil, err
}
childLogger := logger.Named(model.AccountBalancesCollection)
childLogger.Debug("balances store initialised", zap.String("collection", model.AccountBalancesCollection))
childLogger.Debug("Balances store initialised", zap.String("collection", model.AccountBalancesCollection))
return &balancesStore{
logger: childLogger,
@@ -47,7 +47,7 @@ func NewBalances(logger mlogger.Logger, db *mongo.Database) (storage.BalancesSto
func (b *balancesStore) Get(ctx context.Context, accountRef bson.ObjectID) (*model.AccountBalance, error) {
if accountRef.IsZero() {
b.logger.Warn("attempt to get balance with zero account ID")
b.logger.Warn("Attempt to get balance with zero account ID")
return nil, merrors.InvalidArgument("balancesStore: zero account ID")
}
@@ -56,25 +56,25 @@ func (b *balancesStore) Get(ctx context.Context, accountRef bson.ObjectID) (*mod
result := &model.AccountBalance{}
if err := b.repo.FindOneByFilter(ctx, query, result); err != nil {
if errors.Is(err, merrors.ErrNoData) {
b.logger.Debug("balance not found", mzap.AccRef(accountRef))
b.logger.Debug("Balance not found", mzap.AccRef(accountRef))
return nil, storage.ErrBalanceNotFound
}
b.logger.Warn("failed to get balance", zap.Error(err), mzap.AccRef(accountRef))
b.logger.Warn("Failed to get balance", zap.Error(err), mzap.AccRef(accountRef))
return nil, err
}
b.logger.Debug("balance loaded", mzap.AccRef(accountRef),
b.logger.Debug("Balance loaded", mzap.AccRef(accountRef),
zap.String("balance", result.Balance))
return result, nil
}
func (b *balancesStore) Upsert(ctx context.Context, balance *model.AccountBalance) error {
if balance == nil {
b.logger.Warn("attempt to upsert nil balance")
b.logger.Warn("Attempt to upsert nil balance")
return merrors.InvalidArgument("balancesStore: nil balance")
}
if balance.AccountRef.IsZero() {
b.logger.Warn("attempt to upsert balance with zero account ID")
b.logger.Warn("Attempt to upsert balance with zero account ID")
return merrors.InvalidArgument("balancesStore: zero account ID")
}
@@ -83,24 +83,24 @@ func (b *balancesStore) Upsert(ctx context.Context, balance *model.AccountBalanc
if err := b.repo.FindOneByFilter(ctx, filter, existing); err != nil {
if errors.Is(err, merrors.ErrNoData) {
b.logger.Debug("inserting new balance", zap.String("accountRef", balance.AccountRef.Hex()))
b.logger.Debug("Inserting new balance", zap.String("accountRef", balance.AccountRef.Hex()))
return b.repo.Insert(ctx, balance, filter)
}
b.logger.Warn("failed to fetch balance", zap.Error(err), zap.String("accountRef", balance.AccountRef.Hex()))
b.logger.Warn("Failed to fetch balance", zap.Error(err), zap.String("accountRef", balance.AccountRef.Hex()))
return err
}
if existing.GetID() != nil {
balance.SetID(*existing.GetID())
}
b.logger.Debug("updating balance", zap.String("accountRef", balance.AccountRef.Hex()),
b.logger.Debug("Updating balance", zap.String("accountRef", balance.AccountRef.Hex()),
zap.String("balance", balance.Balance))
return b.repo.Update(ctx, balance)
}
func (b *balancesStore) IncrementBalance(ctx context.Context, accountRef bson.ObjectID, amount string) error {
if accountRef.IsZero() {
b.logger.Warn("attempt to increment balance with zero account ID")
b.logger.Warn("Attempt to increment balance with zero account ID")
return merrors.InvalidArgument("balancesStore: zero account ID")
}

38
api/ledger/storage/mongo/store/journal_entries.go
View File

@@ -33,7 +33,7 @@ func NewJournalEntries(logger mlogger.Logger, db *mongo.Database) (storage.Journ
Unique: true,
}
if err := repo.CreateIndex(uniqueIndex); err != nil {
logger.Error("failed to ensure journal entries idempotency index", zap.Error(err))
logger.Error("Failed to ensure journal entries idempotency index", zap.Error(err))
return nil, err
}
@@ -45,12 +45,12 @@ func NewJournalEntries(logger mlogger.Logger, db *mongo.Database) (storage.Journ
},
}
if err := repo.CreateIndex(orgIndex); err != nil {
logger.Error("failed to ensure journal entries organization index", zap.Error(err))
logger.Error("Failed to ensure journal entries organization index", zap.Error(err))
return nil, err
}
childLogger := logger.Named(model.JournalEntriesCollection)
childLogger.Debug("journal entries store initialised", zap.String("collection", model.JournalEntriesCollection))
childLogger.Debug("Journal entries store initialised", zap.String("collection", model.JournalEntriesCollection))
return &journalEntriesStore{
logger: childLogger,
@@ -60,52 +60,52 @@ func NewJournalEntries(logger mlogger.Logger, db *mongo.Database) (storage.Journ
func (j *journalEntriesStore) Create(ctx context.Context, entry *model.JournalEntry) error {
if entry == nil {
j.logger.Warn("attempt to create nil journal entry")
j.logger.Warn("Attempt to create nil journal entry")
return merrors.InvalidArgument("journalEntriesStore: nil journal entry")
}
if err := j.repo.Insert(ctx, entry, nil); err != nil {
if mongo.IsDuplicateKeyError(err) {
j.logger.Warn("duplicate idempotency key", zap.String("idempotency_key", entry.IdempotencyKey))
j.logger.Warn("Duplicate idempotency key", zap.String("idempotency_key", entry.IdempotencyKey))
return storage.ErrDuplicateIdempotency
}
j.logger.Warn("failed to create journal entry", zap.Error(err))
j.logger.Warn("Failed to create journal entry", zap.Error(err))
return err
}
j.logger.Debug("journal entry created", zap.String("idempotency_key", entry.IdempotencyKey),
j.logger.Debug("Journal entry created", zap.String("idempotency_key", entry.IdempotencyKey),
zap.String("entryType", string(entry.EntryType)))
return nil
}
func (j *journalEntriesStore) Get(ctx context.Context, entryRef bson.ObjectID) (*model.JournalEntry, error) {
if entryRef.IsZero() {
j.logger.Warn("attempt to get journal entry with zero ID")
j.logger.Warn("Attempt to get journal entry with zero ID")
return nil, merrors.InvalidArgument("journalEntriesStore: zero entry ID")
}
result := &model.JournalEntry{}
if err := j.repo.Get(ctx, entryRef, result); err != nil {
if errors.Is(err, merrors.ErrNoData) {
j.logger.Debug("journal entry not found", mzap.ObjRef("entry_ref", entryRef))
j.logger.Debug("Journal entry not found", mzap.ObjRef("entry_ref", entryRef))
return nil, storage.ErrJournalEntryNotFound
}
j.logger.Warn("failed to get journal entry", zap.Error(err), mzap.ObjRef("entry_ref", entryRef))
j.logger.Warn("Failed to get journal entry", zap.Error(err), mzap.ObjRef("entry_ref", entryRef))
return nil, err
}
j.logger.Debug("journal entry loaded", mzap.ObjRef("entry_ref", entryRef),
j.logger.Debug("Journal entry loaded", mzap.ObjRef("entry_ref", entryRef),
zap.String("idempotency_key", result.IdempotencyKey))
return result, nil
}
func (j *journalEntriesStore) GetByIdempotencyKey(ctx context.Context, orgRef bson.ObjectID, idempotencyKey string) (*model.JournalEntry, error) {
if orgRef.IsZero() {
j.logger.Warn("attempt to get journal entry with zero organization ID")
j.logger.Warn("Attempt to get journal entry with zero organization ID")
return nil, merrors.InvalidArgument("journalEntriesStore: zero organization ID")
}
if idempotencyKey == "" {
j.logger.Warn("attempt to get journal entry with empty idempotency key")
j.logger.Warn("Attempt to get journal entry with empty idempotency key")
return nil, merrors.InvalidArgument("journalEntriesStore: empty idempotency key")
}
@@ -116,21 +116,21 @@ func (j *journalEntriesStore) GetByIdempotencyKey(ctx context.Context, orgRef bs
result := &model.JournalEntry{}
if err := j.repo.FindOneByFilter(ctx, query, result); err != nil {
if errors.Is(err, merrors.ErrNoData) {
j.logger.Debug("journal entry not found by idempotency key", zap.String("idempotency_key", idempotencyKey))
j.logger.Debug("Journal entry not found by idempotency key", zap.String("idempotency_key", idempotencyKey))
return nil, storage.ErrJournalEntryNotFound
}
j.logger.Warn("failed to get journal entry by idempotency key", zap.Error(err),
j.logger.Warn("Failed to get journal entry by idempotency key", zap.Error(err),
zap.String("idempotency_key", idempotencyKey))
return nil, err
}
j.logger.Debug("journal entry loaded by idempotency key", zap.String("idempotency_key", idempotencyKey))
j.logger.Debug("Journal entry loaded by idempotency key", zap.String("idempotency_key", idempotencyKey))
return result, nil
}
func (j *journalEntriesStore) ListByOrganization(ctx context.Context, orgRef bson.ObjectID, limit int, offset int) ([]*model.JournalEntry, error) {
if orgRef.IsZero() {
j.logger.Warn("attempt to list journal entries with zero organization ID")
j.logger.Warn("Attempt to list journal entries with zero organization ID")
return nil, merrors.InvalidArgument("journalEntriesStore: zero organization ID")
}
@@ -152,10 +152,10 @@ func (j *journalEntriesStore) ListByOrganization(ctx context.Context, orgRef bso
return nil
})
if err != nil {
j.logger.Warn("failed to list journal entries", zap.Error(err))
j.logger.Warn("Failed to list journal entries", zap.Error(err))
return nil, err
}
j.logger.Debug("listed journal entries", zap.Int("count", len(entries)))
j.logger.Debug("Listed journal entries", zap.Int("count", len(entries)))
return entries, nil
}

36
api/ledger/storage/mongo/store/outbox.go
View File

@@ -31,7 +31,7 @@ func NewOutbox(logger mlogger.Logger, db *mongo.Database) (storage.OutboxStore,
},
}
if err := repo.CreateIndex(statusIndex); err != nil {
logger.Error("failed to ensure outbox status index", zap.Error(err))
logger.Error("Failed to ensure outbox status index", zap.Error(err))
return nil, err
}
@@ -43,12 +43,12 @@ func NewOutbox(logger mlogger.Logger, db *mongo.Database) (storage.OutboxStore,
Unique: true,
}
if err := repo.CreateIndex(eventIdIndex); err != nil {
logger.Error("failed to ensure outbox eventId index", zap.Error(err))
logger.Error("Failed to ensure outbox eventId index", zap.Error(err))
return nil, err
}
childLogger := logger.Named(model.OutboxCollection)
childLogger.Debug("outbox store initialised", zap.String("collection", model.OutboxCollection))
childLogger.Debug("Outbox store initialised", zap.String("collection", model.OutboxCollection))
return &outboxStore{
logger: childLogger,
@@ -58,20 +58,20 @@ func NewOutbox(logger mlogger.Logger, db *mongo.Database) (storage.OutboxStore,
func (o *outboxStore) Create(ctx context.Context, event *model.OutboxEvent) error {
if event == nil {
o.logger.Warn("attempt to create nil outbox event")
o.logger.Warn("Attempt to create nil outbox event")
return merrors.InvalidArgument("outboxStore: nil outbox event")
}
if err := o.repo.Insert(ctx, event, nil); err != nil {
if mongo.IsDuplicateKeyError(err) {
o.logger.Warn("duplicate event ID", zap.String("eventId", event.EventID))
o.logger.Warn("Duplicate event ID", zap.String("eventId", event.EventID))
return merrors.DataConflict("outbox event with this ID already exists")
}
o.logger.Warn("failed to create outbox event", zap.Error(err))
o.logger.Warn("Failed to create outbox event", zap.Error(err))
return err
}
o.logger.Debug("outbox event created", zap.String("eventId", event.EventID),
o.logger.Debug("Outbox event created", zap.String("eventId", event.EventID),
zap.String("subject", event.Subject))
return nil
}
@@ -93,17 +93,17 @@ func (o *outboxStore) ListPending(ctx context.Context, limit int) ([]*model.Outb
return nil
})
if err != nil {
o.logger.Warn("failed to list pending outbox events", zap.Error(err))
o.logger.Warn("Failed to list pending outbox events", zap.Error(err))
return nil, err
}
o.logger.Debug("listed pending outbox events", zap.Int("count", len(events)))
o.logger.Debug("Listed pending outbox events", zap.Int("count", len(events)))
return events, nil
}
func (o *outboxStore) MarkSent(ctx context.Context, eventRef bson.ObjectID, sentAt time.Time) error {
if eventRef.IsZero() {
o.logger.Warn("attempt to mark sent with zero event ID")
o.logger.Warn("Attempt to mark sent with zero event ID")
return merrors.InvalidArgument("outboxStore: zero event ID")
}
@@ -112,44 +112,44 @@ func (o *outboxStore) MarkSent(ctx context.Context, eventRef bson.ObjectID, sent
Set(repository.Field("sentAt"), sentAt)
if err := o.repo.Patch(ctx, eventRef, patch); err != nil {
o.logger.Warn("failed to mark outbox event as sent", zap.Error(err), zap.String("eventRef", eventRef.Hex()))
o.logger.Warn("Failed to mark outbox event as sent", zap.Error(err), zap.String("eventRef", eventRef.Hex()))
return err
}
o.logger.Debug("outbox event marked as sent", zap.String("eventRef", eventRef.Hex()))
o.logger.Debug("Outbox event marked as sent", zap.String("eventRef", eventRef.Hex()))
return nil
}
func (o *outboxStore) MarkFailed(ctx context.Context, eventRef bson.ObjectID) error {
if eventRef.IsZero() {
o.logger.Warn("attempt to mark failed with zero event ID")
o.logger.Warn("Attempt to mark failed with zero event ID")
return merrors.InvalidArgument("outboxStore: zero event ID")
}
patch := repository.Patch().Set(repository.Field("status"), model.OutboxStatusFailed)
if err := o.repo.Patch(ctx, eventRef, patch); err != nil {
o.logger.Warn("failed to mark outbox event as failed", zap.Error(err), zap.String("eventRef", eventRef.Hex()))
o.logger.Warn("Failed to mark outbox event as failed", zap.Error(err), zap.String("eventRef", eventRef.Hex()))
return err
}
o.logger.Debug("outbox event marked as failed", zap.String("eventRef", eventRef.Hex()))
o.logger.Debug("Outbox event marked as failed", zap.String("eventRef", eventRef.Hex()))
return nil
}
func (o *outboxStore) IncrementAttempts(ctx context.Context, eventRef bson.ObjectID) error {
if eventRef.IsZero() {
o.logger.Warn("attempt to increment attempts with zero event ID")
o.logger.Warn("Attempt to increment attempts with zero event ID")
return merrors.InvalidArgument("outboxStore: zero event ID")
}
patch := repository.Patch().Inc(repository.Field("attempts"), 1)
if err := o.repo.Patch(ctx, eventRef, patch); err != nil {
o.logger.Warn("failed to increment outbox attempts", zap.Error(err), zap.String("eventRef", eventRef.Hex()))
o.logger.Warn("Failed to increment outbox attempts", zap.Error(err), zap.String("eventRef", eventRef.Hex()))
return err
}
o.logger.Debug("outbox attempts incremented", zap.String("eventRef", eventRef.Hex()))
o.logger.Debug("Outbox attempts incremented", zap.String("eventRef", eventRef.Hex()))
return nil
}

26
api/ledger/storage/mongo/store/posting_lines.go
View File

@@ -31,7 +31,7 @@ func NewPostingLines(logger mlogger.Logger, db *mongo.Database) (storage.Posting
},
}
if err := repo.CreateIndex(entryIndex); err != nil {
logger.Error("failed to ensure posting lines entry index", zap.Error(err))
logger.Error("Failed to ensure posting lines entry index", zap.Error(err))
return nil, err
}
@@ -43,12 +43,12 @@ func NewPostingLines(logger mlogger.Logger, db *mongo.Database) (storage.Posting
},
}
if err := repo.CreateIndex(accountIndex); err != nil {
logger.Error("failed to ensure posting lines account index", zap.Error(err))
logger.Error("Failed to ensure posting lines account index", zap.Error(err))
return nil, err
}
childLogger := logger.Named(model.PostingLinesCollection)
childLogger.Debug("posting lines store initialised", zap.String("collection", model.PostingLinesCollection))
childLogger.Debug("Posting lines store initialised", zap.String("collection", model.PostingLinesCollection))
return &postingLinesStore{
logger: childLogger,
@@ -58,31 +58,31 @@ func NewPostingLines(logger mlogger.Logger, db *mongo.Database) (storage.Posting
func (p *postingLinesStore) CreateMany(ctx context.Context, lines []*model.PostingLine) error {
if len(lines) == 0 {
p.logger.Warn("attempt to create empty posting lines array")
p.logger.Warn("Attempt to create empty posting lines array")
return nil
}
storables := make([]storable.Storable, len(lines))
for i, line := range lines {
if line == nil {
p.logger.Warn("attempt to create nil posting line")
p.logger.Warn("Attempt to create nil posting line")
return merrors.InvalidArgument("postingLinesStore: nil posting line")
}
storables[i] = line
}
if err := p.repo.InsertMany(ctx, storables); err != nil {
p.logger.Warn("failed to create posting lines", zap.Error(err), zap.Int("count", len(lines)))
p.logger.Warn("Failed to create posting lines", zap.Error(err), zap.Int("count", len(lines)))
return err
}
p.logger.Debug("posting lines created", zap.Int("count", len(lines)))
p.logger.Debug("Posting lines created", zap.Int("count", len(lines)))
return nil
}
func (p *postingLinesStore) ListByJournalEntry(ctx context.Context, entryRef bson.ObjectID) ([]*model.PostingLine, error) {
if entryRef.IsZero() {
p.logger.Warn("attempt to list posting lines with zero entry ID")
p.logger.Warn("Attempt to list posting lines with zero entry ID")
return nil, merrors.InvalidArgument("postingLinesStore: zero entry ID")
}
@@ -98,17 +98,17 @@ func (p *postingLinesStore) ListByJournalEntry(ctx context.Context, entryRef bso
return nil
})
if err != nil {
p.logger.Warn("failed to list posting lines by entry", zap.Error(err), mzap.ObjRef("entry_ref", entryRef))
p.logger.Warn("Failed to list posting lines by entry", zap.Error(err), mzap.ObjRef("entry_ref", entryRef))
return nil, err
}
p.logger.Debug("listed posting lines by entry", zap.Int("count", len(lines)), mzap.ObjRef("entry_ref", entryRef))
p.logger.Debug("Listed posting lines by entry", zap.Int("count", len(lines)), mzap.ObjRef("entry_ref", entryRef))
return lines, nil
}
func (p *postingLinesStore) ListByAccount(ctx context.Context, accountRef bson.ObjectID, limit int, offset int) ([]*model.PostingLine, error) {
if accountRef.IsZero() {
p.logger.Warn("attempt to list posting lines with zero account ID")
p.logger.Warn("Attempt to list posting lines with zero account ID")
return nil, merrors.InvalidArgument("postingLinesStore: zero account ID")
}
@@ -130,10 +130,10 @@ func (p *postingLinesStore) ListByAccount(ctx context.Context, accountRef bson.O
return nil
})
if err != nil {
p.logger.Warn("failed to list posting lines by account", zap.Error(err), mzap.AccRef(accountRef))
p.logger.Warn("Failed to list posting lines by account", zap.Error(err), mzap.AccRef(accountRef))
return nil, err
}
p.logger.Debug("listed posting lines by account", zap.Int("count", len(lines)), mzap.AccRef(accountRef))
p.logger.Debug("Listed posting lines by account", zap.Int("count", len(lines)), mzap.AccRef(accountRef))
return lines, nil
}