sink

type ClickHouseStorage struct {
	// contains filtered or unexported fields
}

type ClickHouseStorageConfig struct {
	Streaming streaming.Connector
}

type MetersByType map[string][]*meter.Meter

type NamespacedMeterCache struct {
	// contains filtered or unexported fields
}

type NamespacedMeterCacheConfig struct {
	PeriodicRefetchInterval time.Duration
	Logger                  *slog.Logger
	MeterService            meter.Service
}

type Sink struct {
	// contains filtered or unexported fields
}

type SinkBuffer struct {
	// contains filtered or unexported fields
}

type SinkConfig struct {
	Logger       *slog.Logger
	Tracer       trace.Tracer
	MetricMeter  metric.Meter
	Storage      Storage
	Deduplicator dedupe.Deduplicator
	Consumer     *kafka.Consumer
	// MinCommitCount is the minimum number of messages to wait before flushing the buffer.
	// Whichever happens earlier MinCommitCount or MaxCommitWait will trigger a flush.
	MinCommitCount int
	// MaxCommitWait is the maximum time to wait before flushing the buffer
	MaxCommitWait time.Duration
	// The time, in milliseconds, spent waiting in poll if data is not available in the buffer.
	// If 0, returns immediately with any records that are available currently in the buffer, else returns empty.
	MaxPollTimeout time.Duration
	// NamespaceRefetch is the interval to refetch exsisting namespaces and meters
	// this information is used to configure which topics the consumer subscribes and
	// the meter configs used in event validation.
	NamespaceRefetch time.Duration

	// NamespaceRefetchTimeout is the timeout for updating namespaces and consumer subscription.
	// It must be less than NamespaceRefetch interval.
	NamespaceRefetchTimeout time.Duration

	// NamespaceTopicRegexp defines the regular expression to match/validate topic names the sink-worker needs to subscribe to.
	NamespaceTopicRegexp string

	// FlushEventHandlers is an optional lifecycle hook, allowing to act on successful batch
	// flushes. To prevent blocking the main sink logic this is always called in a go routine.
	FlushEventHandler flushhandler.FlushEventHandler

	// FlushSuccessTimeout is the timeout for the OnFlushSuccess callback,
	// after this period the context of the callback will be canceled.
	FlushSuccessTimeout time.Duration

	// DrainTimeout is the maximum time to wait before draining the buffer and closing the sink.
	DrainTimeout time.Duration

	TopicResolver topicresolver.Resolver

	// MeterRefetchInterval is the interval to refetch meters from the database
	MeterRefetchInterval time.Duration

	// MeterService is the service to fetch meters from the database
	MeterService meter.Service
}

type Storage interface {
	BatchInsert(ctx context.Context, messages []sinkmodels.SinkMessage) error
}