feat: Keep-Alive correlation, TTL management, SIGHUP handling, logrotate support

Major features:
- One-to-many correlation mode (Keep-Alive) for HTTP connections
- Dynamic TTL for network events with reset on each correlation
- Separate configurable buffer sizes for HTTP and network events
- SIGHUP signal handling for log rotation without service restart
- FileSink.Reopen() method for log file rotation
- logrotate configuration included in RPM
- ExecReload added to systemd service

Configuration changes:
- New YAML structure with nested sections (time_window, orphan_policy, matching, buffers, ttl)
- Backward compatibility maintained for deprecated fields

Packaging:
- RPM version 1.1.0 with logrotate config
- Updated spec file and changelog
- All distributions: el8, el9, el10

Tests:
- New tests for Keep-Alive mode and TTL reset
- Updated mocks with Reopen() interface method

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

internal/adapters/outbound/clickhouse/sink.go

@@ -115,6 +115,11 @@ func (s *ClickHouseSink) Name() string {
 	return "clickhouse"
 }
 
+// Reopen is a no-op for ClickHouse (connection is managed internally).
+func (s *ClickHouseSink) Reopen() error {
+	return nil
+}
+
 // Write adds a log to the buffer.
 func (s *ClickHouseSink) Write(ctx context.Context, log domain.CorrelatedLog) error {
 	deadline := time.Now().Add(time.Duration(s.config.TimeoutMs) * time.Millisecond)

internal/adapters/outbound/file/sink.go

@@ -38,9 +38,16 @@ func NewFileSink(config Config) (*FileSink, error) {
 		return nil, fmt.Errorf("invalid file path: %w", err)
 	}
 
-	return &FileSink{
+	s := &FileSink{
 		config: config,
-	}, nil
+	}
+
+	// Open file on creation
+	if err := s.openFile(); err != nil {
+		return nil, err
+	}
+
+	return s, nil
 }
 
 // Name returns the sink name.
@@ -48,6 +55,20 @@ func (s *FileSink) Name() string {
 	return "file"
 }
 
+// Reopen closes and reopens the file (for log rotation on SIGHUP).
+func (s *FileSink) Reopen() error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if s.file != nil {
+		if err := s.file.Close(); err != nil {
+			return fmt.Errorf("failed to close file: %w", err)
+		}
+	}
+
+	return s.openFile()
+}
+
 // Write writes a correlated log to the file.
 func (s *FileSink) Write(ctx context.Context, log domain.CorrelatedLog) error {
 	s.mu.Lock()

internal/adapters/outbound/multi/sink.go

@@ -121,3 +121,17 @@ func (s *MultiSink) Close() error {
 	}
 	return firstErr
 }
+
+// Reopen reopens all sinks (for log rotation on SIGHUP).
+func (s *MultiSink) Reopen() error {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	var firstErr error
+	for _, sink := range s.sinks {
+		if err := sink.Reopen(); err != nil && firstErr == nil {
+			firstErr = err
+		}
+	}
+	return firstErr
+}

internal/adapters/outbound/multi/sink_test.go

@@ -14,6 +14,7 @@ type mockSink struct {
 	writeFunc func(domain.CorrelatedLog) error
 	flushFunc func() error
 	closeFunc func() error
+	reopenFunc func() error
 }
 
 func (m *mockSink) Name() string                              { return m.name }
@@ -24,6 +25,12 @@ func (m *mockSink) Write(ctx context.Context, log domain.CorrelatedLog) error {
 }
 func (m *mockSink) Flush(ctx context.Context) error { return m.flushFunc() }
 func (m *mockSink) Close() error                    { return m.closeFunc() }
+func (m *mockSink) Reopen() error                   { 
+	if m.reopenFunc != nil {
+		return m.reopenFunc()
+	}
+	return nil
+}
 
 func TestMultiSink_Write(t *testing.T) {
 	var mu sync.Mutex

internal/adapters/outbound/stdout/sink.go

@@ -35,6 +35,11 @@ func (s *StdoutSink) Name() string {
 	return "stdout"
 }
 
+// Reopen is a no-op for stdout.
+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()