curlyq

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

type ConsumerOpts struct {
	// Address specifies the address of the Redis backing your queue.
	// CurlyQ will generate a go-redis instance based on this address.
	Address string
	// Client is a custom go-redis instance used to communicate with Redis.
	// If provided, this option overrides the value set in Address.
	Client *redis.Client
	// Queue specifies the name of the queue that this consumer will consume from.
	Queue string

	// Logger provides a concrete implementation of the Logger interface.
	// If not provided, it will default to using the stdlib's log package.
	Logger Logger
	// The maximum number of times to retry a job before killing it.
	// Default: 20
	JobMaxAttempts int
	// The maximum delay between retry attempts.
	// Default: 1 week
	JobMaxBackoff time.Duration
	// How long to wait for executors to finish before exiting forcibly.
	// A zero value indicates that we should wait indefinitely.
	// Default: 0
	ShutdownGracePeriod time.Duration

	// How long to wait after a missed heartbeat before a consumer is considered dead.
	// Default: 1 minute
	// Minimum: 5 seconds
	CustodianConsumerTimeout time.Duration
	// The maximum number of failed attempts before aborting.
	// A zero value indiciates the custodian should never abort.
	// Default: 0
	CustodianMaxAttempts int
	// The longest amount of time to wait between failed attempts.
	// Default: 30 seconds
	CustodianMaxBackoff time.Duration
	// Max number of jobs to clean up during a single check.
	// Default: 50
	CustodianMaxJobs int
	// How frequently the custodian should clean up jobs.
	// Default: 1 minute
	CustodianPollInterval time.Duration

	// The maximum number of failed attempts before aborting.
	// A zero value indiciates the hearbeart should never abort.
	// Default: 0
	HeartbeatMaxAttempts int
	// The longest amount of time to wait between failed attempts.
	// Default: 30 seconds
	HeartbeatMaxBackoff time.Duration
	// How frequently we should heartbeat.
	// Default: 1 minute
	// Minimum: 15 seconds
	HeartbeatPollInterval time.Duration

	// How many jobs to buffer locally.
	// Default: 10
	PollerBufferSize int
	// The maximum number of failed attempts before aborting.
	// A zero value indiciates the poller should never abort.
	// Default: 0
	PollerMaxAttempts int
	// The longest amount of time to wait between failed attempts.
	// Default: 30 seconds
	PollerMaxBackoff time.Duration
	// How long we should block on Redis for new jobs on each call.
	// Default: 5 seconds
	// Minimum: 1 second
	PollerPollDuration time.Duration

	// How many jobs to process simultaneously.
	// Default: 5
	ProcessorConcurrency int

	// The maximum number of failed attempts before aborting.
	// A zero value indiciates the scheduler should never abort.
	// Default: 0
	SchedulerMaxAttempts int
	// The longest amount of time to wait between failed attempts.
	// Default: 30 seconds
	SchedulerMaxBackoff time.Duration
	// Max number of jobs to schedule during each check.
	// Default: 50
	SchedulerMaxJobs int
	// How frequently the scheduler should check for scheduled jobs.
	// Default: 5 seconds
	SchedulerPollInterval time.Duration
}

type DefaultLogger struct{}

type EmptyLogger struct{}

type ErrExceededMaxBackoff struct {
	Attempt int
	Process string
}

type ErrFailedToAckJob struct {
	Job Job
	Err error
}

type ErrFailedToKillJob struct {
	Job Job
	Err error
}

type ErrFailedToRetryJob struct {
	Job Job
	Err error
}

type HandlerFunc func(context.Context, Job) error

type Job struct {
	ID      string
	Data    []byte
	Attempt int
}

type Logger interface {
	// Debug logs fine-grained information,
	// such as when a given process starts and ends.
	Debug(...interface{})

	// Info logs useful information,
	// such as which job is currently being processed.
	Info(...interface{})

	// Warn logs non-critical errors,
	// such as network issues that are treated as transient errors.
	Warn(...interface{})

	// Error logs critical errors,
	// such as redis issues which might affect the consistency of the queue.
	Error(...interface{})
}

type LoudLogger struct{}

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

type ProducerOpts struct {
	// Address specifies the address of the Redis backing your queue.
	// CurlyQ will generate a go-redis instance based on this address.
	Address string
	// Client is a custom go-redis instance used to communicate with Redis.
	// If provided, this option overrides the value set in Address.
	Client *redis.Client
	// Logger provides a concrete implementation of the Logger interface.
	// If not provided, it will default to using the stdlib's log package.
	Logger Logger
	// Queue specifies the name of the queue that this producer will push to.
	Queue string
}