Initial commit: logcorrelator with unified packaging (DEB + RPM using fpm)

Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>

internal/adapters/outbound/multi/sink.go

@@ -0,0 +1,123 @@
+package multi
+
+import (
+	"context"
+	"sync"
+
+	"github.com/logcorrelator/logcorrelator/internal/domain"
+	"github.com/logcorrelator/logcorrelator/internal/ports"
+)
+
+// MultiSink fans out correlated logs to multiple sinks.
+type MultiSink struct {
+	mu    sync.RWMutex
+	sinks []ports.CorrelatedLogSink
+}
+
+// NewMultiSink creates a new multi-sink.
+func NewMultiSink(sinks ...ports.CorrelatedLogSink) *MultiSink {
+	return &MultiSink{
+		sinks: sinks,
+	}
+}
+
+// Name returns the sink name.
+func (s *MultiSink) Name() string {
+	return "multi"
+}
+
+// AddSink adds a sink to the fan-out.
+func (s *MultiSink) AddSink(sink ports.CorrelatedLogSink) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.sinks = append(s.sinks, sink)
+}
+
+// Write writes a correlated log to all sinks concurrently.
+// Returns the first error encountered (but all sinks are attempted).
+func (s *MultiSink) Write(ctx context.Context, log domain.CorrelatedLog) error {
+	s.mu.RLock()
+	sinks := make([]ports.CorrelatedLogSink, len(s.sinks))
+	copy(sinks, s.sinks)
+	s.mu.RUnlock()
+
+	if len(sinks) == 0 {
+		return nil
+	}
+
+	var wg sync.WaitGroup
+	var firstErr error
+	var firstErrMu sync.Mutex
+	errChan := make(chan error, len(sinks))
+
+	for _, sink := range sinks {
+		wg.Add(1)
+		go func(sk ports.CorrelatedLogSink) {
+			defer wg.Done()
+			if err := sk.Write(ctx, log); err != nil {
+				// Non-blocking send to errChan
+				select {
+				case errChan <- err:
+				default:
+					// Channel full, error will be handled via firstErr
+				}
+			}
+		}(sink)
+	}
+
+	// Wait for all writes to complete in a separate goroutine
+	done := make(chan struct{})
+	go func() {
+		wg.Wait()
+		close(done)
+	}()
+
+	// Collect errors with timeout
+	select {
+	case <-done:
+		close(errChan)
+		// Collect first error
+		for err := range errChan {
+			if err != nil {
+				firstErrMu.Lock()
+				if firstErr == nil {
+					firstErr = err
+				}
+				firstErrMu.Unlock()
+			}
+		}
+	case <-ctx.Done():
+		return ctx.Err()
+	}
+
+	firstErrMu.Lock()
+	defer firstErrMu.Unlock()
+	return firstErr
+}
+
+// Flush flushes all sinks.
+func (s *MultiSink) Flush(ctx context.Context) error {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	for _, sink := range s.sinks {
+		if err := sink.Flush(ctx); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Close closes all sinks.
+func (s *MultiSink) Close() error {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	var firstErr error
+	for _, sink := range s.sinks {
+		if err := sink.Close(); err != nil && firstErr == nil {
+			firstErr = err
+		}
+	}
+	return firstErr
+}

internal/adapters/outbound/multi/sink_test.go

@@ -0,0 +1,114 @@
+package multi
+
+import (
+	"context"
+	"sync"
+	"testing"
+
+	"github.com/logcorrelator/logcorrelator/internal/domain"
+)
+
+type mockSink struct {
+	name      string
+	mu        sync.Mutex
+	writeFunc func(domain.CorrelatedLog) error
+	flushFunc func() error
+	closeFunc func() error
+}
+
+func (m *mockSink) Name() string                              { return m.name }
+func (m *mockSink) Write(ctx context.Context, log domain.CorrelatedLog) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	return m.writeFunc(log)
+}
+func (m *mockSink) Flush(ctx context.Context) error { return m.flushFunc() }
+func (m *mockSink) Close() error                    { return m.closeFunc() }
+
+func TestMultiSink_Write(t *testing.T) {
+	var mu sync.Mutex
+	writeCount := 0
+
+	sink1 := &mockSink{
+		name: "sink1",
+		writeFunc: func(log domain.CorrelatedLog) error {
+			mu.Lock()
+			writeCount++
+			mu.Unlock()
+			return nil
+		},
+		flushFunc: func() error { return nil },
+		closeFunc: func() error { return nil },
+	}
+
+	sink2 := &mockSink{
+		name: "sink2",
+		writeFunc: func(log domain.CorrelatedLog) error {
+			mu.Lock()
+			writeCount++
+			mu.Unlock()
+			return nil
+		},
+		flushFunc: func() error { return nil },
+		closeFunc: func() error { return nil },
+	}
+
+	ms := NewMultiSink(sink1, sink2)
+
+	log := domain.CorrelatedLog{SrcIP: "192.168.1.1"}
+	err := ms.Write(context.Background(), log)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	if writeCount != 2 {
+		t.Errorf("expected 2 writes, got %d", writeCount)
+	}
+}
+
+func TestMultiSink_Write_OneFails(t *testing.T) {
+	sink1 := &mockSink{
+		name: "sink1",
+		writeFunc: func(log domain.CorrelatedLog) error {
+			return nil
+		},
+		flushFunc: func() error { return nil },
+		closeFunc: func() error { return nil },
+	}
+
+	sink2 := &mockSink{
+		name: "sink2",
+		writeFunc: func(log domain.CorrelatedLog) error {
+			return context.Canceled
+		},
+		flushFunc: func() error { return nil },
+		closeFunc: func() error { return nil },
+	}
+
+	ms := NewMultiSink(sink1, sink2)
+
+	log := domain.CorrelatedLog{SrcIP: "192.168.1.1"}
+	err := ms.Write(context.Background(), log)
+	if err == nil {
+		t.Error("expected error when one sink fails")
+	}
+}
+
+func TestMultiSink_AddSink(t *testing.T) {
+	ms := NewMultiSink()
+
+	sink := &mockSink{
+		name: "dynamic",
+		writeFunc: func(log domain.CorrelatedLog) error { return nil },
+		flushFunc: func() error { return nil },
+		closeFunc: func() error { return nil },
+	}
+
+	ms.AddSink(sink)
+
+	log := domain.CorrelatedLog{SrcIP: "192.168.1.1"}
+	err := ms.Write(context.Background(), log)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}