taskhawk

type Config struct {
	// Sync changes taskhawk dispatch to synchronous mode. This is similar
	// to Celery's Eager mode and is helpful for integration testing
	Sync bool

	// Instrumenter for the consumer
	Instrumenter Instrumenter

	// GetLogger returns the logger object for given context
	GetLogger GetLoggerFunc
}

type ConsumerBackend interface {
	// Receive messages from configured queue(s) and provide it through the channel. This should run indefinitely
	// until the context is canceled. Provider metadata should include all info necessary to ack/nack a message.
	// The channel must not be closed by the backend.
	Receive(ctx context.Context, priority Priority, numMessages uint32, visibilityTimeout time.Duration, messageCh chan<- ReceivedMessage) error

	// NackMessage nacks a message on the queue
	NackMessage(ctx context.Context, providerMetadata any) error

	// AckMessage acknowledges a message on the queue
	AckMessage(ctx context.Context, providerMetadata any) error

	// RequeueDLQ re-queues everything in the taskhawk DLQ back into the taskhawk queue
	RequeueDLQ(ctx context.Context, priority Priority, numMessages uint32, visibilityTimeout time.Duration) error
}

type GetLoggerFunc func(ctx context.Context) Logger

type HeadersCarrier interface {
	// SetHeaders sets the headers on a task input
	SetHeaders(map[string]string)

	// GetHeaders returns the headers set on a task input
	GetHeaders() map[string]string
}

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

type Instrumenter interface {
	// OnReceive is called as soon as possible after a message is received from the backend. Caller must call
	// the returned finalized function when processing for the message is finished (typically done via defer).
	// The context must be replaced with the returned context for the remainder of the operation.
	// This is where a new span must be started.
	OnReceive(ctx context.Context, attributes map[string]string) (context.Context, func())

	// OnTask is called when a message has been received from the backend and decoded
	// This is where span attributes, such as name, may be updated.
	OnTask(ctx context.Context, taskName string)

	// OnDispatch is called right before a message is published. Caller must call
	// the returned finalized function when publishing for the message is finished (typically done via defer).
	// The attributes may be updated to include trace id for downstream consumers.
	OnDispatch(ctx context.Context, taskName string, attributes map[string]string) (context.Context, map[string]string, func())
}

type ListenRequest struct {
	// Priority queue to listen to
	Priority Priority

	// How many messages to fetch at one time
	NumMessages uint32 // default 1

	// How long should the message be hidden from other consumers?
	VisibilityTimeout time.Duration // defaults to queue configuration

	// How many goroutines to spin for processing messages concurrently
	NumConcurrency uint32 // default 1
}

type Logger interface {
	// Error logs an error with a message. `fields` can be used as additional metadata for structured logging.
	// You can generally expect one of these fields to be available: message_sqs_id, message_sns_id.
	// By default fields are logged as a map using fmt.Sprintf
	Error(err error, message string, fields LoggingFields)

	// Warn logs a warn level log with a message. `fields` param works the same as `Error`.
	Warn(err error, message string, fields LoggingFields)

	// Info logs a debug level log with a message. `fields` param works the same as `Error`.
	Info(message string, fields LoggingFields)

	// Debug logs a debug level log with a message. `fields` param works the same as `Error`.
	Debug(message string, fields LoggingFields)
}

type LoggingFields map[string]any

type MetadataSetter interface {
	// SetID sets the message id
	SetID(string)

	// SetPriority sets the priority a message was dispatched with
	SetPriority(Priority)

	// SetProviderMetadata represents backend provider specific metadata, e.g. AWS receipt, or Pub/Sub ack ID
	// For concrete type of metadata, check the documentation of your backend class
	SetProviderMetadata(any)

	// SetTimestamp sets the message dispatch timestamp
	SetTimestamp(time.Time)

	// SetVersion sets the message schema version
	SetVersion(Version)
}

type Priority int

type PublisherBackend interface {
	// Publish a message represented by the payload, with specified attributes to the topic with specified priority
	Publish(ctx context.Context, payload []byte, attributes map[string]string, priority Priority) (string, error)
}

type ReceivedMessage struct {
	Payload          []byte
	Attributes       map[string]string
	ProviderMetadata any
}

type StdLogger struct{}

type Task[T any] struct {
	// contains filtered or unexported fields
}

type TaskFn[T any] func(ctx context.Context, input *T) error

type Version string