feat: observability, IP filtering, stdout/clickhouse fixes (v1.1.11)

- feat(observability): metrics server with /metrics and /health endpoints
- feat(observability): correlation metrics (events, success/failed, reasons, buffers)
- feat(correlation): IP exclusion filter (exact IPs and CIDR ranges)
- feat(correlation): pending orphan delay for late-arriving B events
- fix(stdout): sink is now a no-op for data; JSON must never appear on stdout
- fix(clickhouse): all flush errors were silently discarded, now properly logged
- fix(clickhouse): buffer overflow with DropOnOverflow now logged at WARN
- fix(clickhouse): retry attempts logged at WARN with attempt/delay/error context
- feat(clickhouse): connection success logged at INFO, batch sends at DEBUG
- feat(clickhouse): SetLogger() for external logger injection
- test(stdout): assert stdout remains empty for correlated and orphan logs
- chore(rpm): bump version to 1.1.11, update changelog
- docs: README and architecture.yml updated

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

internal/adapters/outbound/stdout/sink.go

@@ -2,41 +2,22 @@ package stdout
 
 import (
 	"context"
-	"encoding/json"
-	"fmt"
-	"os"
-	"strings"
-	"sync"
 
 	"github.com/logcorrelator/logcorrelator/internal/domain"
-	"github.com/logcorrelator/logcorrelator/internal/observability"
 )
 
 // Config holds the stdout sink configuration.
 type Config struct {
 	Enabled bool
-	Level   string // DEBUG, INFO, WARN, ERROR - filters output verbosity
 }
 
-// StdoutSink writes correlated logs to stdout as JSON lines.
-type StdoutSink struct {
-	config   Config
-	mu       sync.Mutex
-	enc      *json.Encoder
-	minLevel observability.LogLevel
-}
+// StdoutSink is a no-op data sink. Operational logs are written to stderr
+// by the observability.Logger; correlated data must never appear on stdout.
+type StdoutSink struct{}
 
 // NewStdoutSink creates a new stdout sink.
 func NewStdoutSink(config Config) *StdoutSink {
-	level := observability.INFO
-	if config.Level != "" {
-		level = observability.ParseLogLevel(strings.ToUpper(config.Level))
-	}
-	return &StdoutSink{
-		config:   config,
-		enc:      json.NewEncoder(os.Stdout),
-		minLevel: level,
-	}
+	return &StdoutSink{}
 }
 
 // Name returns the sink name.
@@ -49,50 +30,17 @@ func (s *StdoutSink) Reopen() error {
 	return nil
 }
 
-// Write writes a correlated log to stdout.
-func (s *StdoutSink) Write(ctx context.Context, log domain.CorrelatedLog) error {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	// Filter output based on correlation status and log level
-	// DEBUG: all logs, INFO: only correlated, WARN: only correlated with issues, ERROR: none
-	if !s.shouldEmit(log) {
-		return nil
-	}
-
-	if err := s.enc.Encode(log); err != nil {
-		return fmt.Errorf("failed to write to stdout: %w", err)
-	}
-
+// Write is a no-op: correlated data must never be written to stdout.
+func (s *StdoutSink) Write(_ context.Context, _ domain.CorrelatedLog) error {
 	return nil
 }
 
-// shouldEmit determines if a log should be emitted based on its correlation status and configured level.
-func (s *StdoutSink) shouldEmit(log domain.CorrelatedLog) bool {
-	switch s.minLevel {
-	case observability.DEBUG:
-		// Emit everything including orphans
-		return true
-	case observability.INFO:
-		// Emit all correlated logs, skip orphans
-		return log.Correlated
-	case observability.WARN:
-		// Emit only correlated logs (same as INFO for now, can be extended)
-		return log.Correlated
-	case observability.ERROR:
-		// Never emit to stdout at ERROR level
-		return false
-	default:
-		return log.Correlated
-	}
-}
-
-// Flush flushes any buffered data (no-op for stdout).
-func (s *StdoutSink) Flush(ctx context.Context) error {
+// Flush is a no-op for stdout.
+func (s *StdoutSink) Flush(_ context.Context) error {
 	return nil
 }
 
-// Close closes the sink (no-op for stdout).
+// Close is a no-op for stdout.
 func (s *StdoutSink) Close() error {
 	return nil
 }

internal/adapters/outbound/stdout/sink_test.go

@@ -0,0 +1,81 @@
+package stdout
+
+import (
+	"bytes"
+	"context"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/logcorrelator/logcorrelator/internal/domain"
+)
+
+func makeLog(correlated bool) domain.CorrelatedLog {
+	return domain.CorrelatedLog{
+		Timestamp:  time.Unix(1700000000, 0),
+		SrcIP:      "1.2.3.4",
+		SrcPort:    12345,
+		Correlated: correlated,
+	}
+}
+
+// captureStdout replaces os.Stdout temporarily and returns what was written.
+func captureStdout(t *testing.T, fn func()) string {
+	t.Helper()
+	r, w, err := os.Pipe()
+	if err != nil {
+		t.Fatalf("os.Pipe: %v", err)
+	}
+	old := os.Stdout
+	os.Stdout = w
+
+	fn()
+
+	w.Close()
+	os.Stdout = old
+
+	var buf bytes.Buffer
+	buf.ReadFrom(r)
+	r.Close()
+	return buf.String()
+}
+
+func TestStdoutSink_Name(t *testing.T) {
+	s := NewStdoutSink(Config{Enabled: true})
+	if s.Name() != "stdout" {
+		t.Errorf("expected name 'stdout', got %q", s.Name())
+	}
+}
+
+// TestStdoutSink_WriteDoesNotProduceOutput verifies that no JSON data
+// (correlated or not) is ever written to stdout.
+func TestStdoutSink_WriteDoesNotProduceOutput(t *testing.T) {
+	s := NewStdoutSink(Config{Enabled: true})
+
+	got := captureStdout(t, func() {
+		if err := s.Write(context.Background(), makeLog(true)); err != nil {
+			t.Fatalf("Write(correlated) returned error: %v", err)
+		}
+		if err := s.Write(context.Background(), makeLog(false)); err != nil {
+			t.Fatalf("Write(orphan) returned error: %v", err)
+		}
+	})
+
+	if got != "" {
+		t.Errorf("stdout must be empty but got: %q", got)
+	}
+}
+
+func TestStdoutSink_NoopMethods(t *testing.T) {
+	s := NewStdoutSink(Config{Enabled: true})
+
+	if err := s.Flush(context.Background()); err != nil {
+		t.Errorf("Flush returned error: %v", err)
+	}
+	if err := s.Close(); err != nil {
+		t.Errorf("Close returned error: %v", err)
+	}
+	if err := s.Reopen(); err != nil {
+		t.Errorf("Reopen returned error: %v", err)
+	}
+}