dests

package
v0.0.0-...-2081a44 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 10, 2018 License: Apache-2.0 Imports: 42 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var ErrCalculateURL = eerrors.New("Error calculating target URL from template")
View Source 
var Registry *prometheus.Registry

Functions

func InitRegistry 

func InitRegistry()

func IsEncodingError 

func IsEncodingError(err error) bool

IsEncodingError returns true when the given error is a message encoding error

Types

type Destination 

type Destination interface {
	Send(ctx context.Context, m []model.OutputMsg) eerrors.ErrorSlice
	Fatal() chan error
	Close() error
	ACK(utils.MyULID)
	NACK(utils.MyULID)
	PermError(utils.MyULID)
	NACKAllSlice([]*model.FullMessage)
}

func NewDestination 

func NewDestination(ctx context.Context, typ conf.DestinationType, e *Env) (Destination, error)

func NewElasticDestination 

func NewElasticDestination(ctx context.Context, e *Env) (Destination, error)

func NewFileDestination 

func NewFileDestination(ctx context.Context, e *Env) (Destination, error)

func NewGraylogDestination 

func NewGraylogDestination(ctx context.Context, e *Env) (Destination, error)

func NewHTTPDestination 

func NewHTTPDestination(ctx context.Context, e *Env) (Destination, error)

func NewHTTPServerDestination 

func NewHTTPServerDestination(ctx context.Context, e *Env) (Destination, error)

func NewKafkaDestination 

func NewKafkaDestination(ctx context.Context, e *Env) (Destination, error)

func NewNATSDestination 

func NewNATSDestination(ctx context.Context, e *Env) (Destination, error)

func NewRELPDestination 

func NewRELPDestination(ctx context.Context, e *Env) (Destination, error)

func NewRedisDestination 

func NewRedisDestination(ctx context.Context, e *Env) (Destination, error)

func NewStderrDestination 

func NewStderrDestination(ctx context.Context, e *Env) (Destination, error)

func NewTCPDestination 

func NewTCPDestination(ctx context.Context, e *Env) (Destination, error)

func NewUDPDestination 

func NewUDPDestination(ctx context.Context, e *Env) (Destination, error)

func NewWebsocketServerDestination 

func NewWebsocketServerDestination(ctx context.Context, e *Env) (Destination, error)

type ElasticDestination 

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

func (ElasticDestination) ACK 

func (base ElasticDestination) ACK(uid utils.MyULID)

func (*ElasticDestination) Close 

func (d *ElasticDestination) Close() error

func (ElasticDestination) Fatal 

func (base ElasticDestination) Fatal() chan error

func (ElasticDestination) ForEach 

func (base ElasticDestination) ForEach(ctx context.Context, f func(context.Context, *model.FullMessage) error, ackf, free bool, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (ElasticDestination) ForEachWithTopic 

func (base ElasticDestination) ForEachWithTopic(ctx context.Context, f func(context.Context, *model.FullMessage, string, string, int32) error, ackf, free bool, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (ElasticDestination) NACK 

func (base ElasticDestination) NACK(uid utils.MyULID)

func (ElasticDestination) NACKAll 

func (base ElasticDestination) NACKAll(msgQ *message.Ring)

func (ElasticDestination) NACKAllSlice 

func (base ElasticDestination) NACKAllSlice(msgs []*model.FullMessage)

func (ElasticDestination) NACKRemaining 

func (base ElasticDestination) NACKRemaining(msgs []model.OutputMsg)

func (ElasticDestination) PermError 

func (base ElasticDestination) PermError(uid utils.MyULID)

func (*ElasticDestination) Send 

func (d *ElasticDestination) Send(ctx context.Context, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

type Env 

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

func BuildEnv 

func BuildEnv() *Env

func (*Env) Binder 

func (e *Env) Binder(b binder.Client) *Env

func (*Env) Callbacks 

func (e *Env) Callbacks(a, n, p storeCallback) *Env

func (*Env) Config 

func (e *Env) Config(c conf.BaseConfig) *Env

func (*Env) Confined 

func (e *Env) Confined(c bool) *Env

func (*Env) Logger 

func (e *Env) Logger(l log15.Logger) *Env

type FileDestination 

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

func (FileDestination) ACK 

func (base FileDestination) ACK(uid utils.MyULID)

func (*FileDestination) Close 

func (d *FileDestination) Close() error

func (FileDestination) Fatal 

func (base FileDestination) Fatal() chan error

func (FileDestination) ForEach 

func (base FileDestination) ForEach(ctx context.Context, f func(context.Context, *model.FullMessage) error, ackf, free bool, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (FileDestination) ForEachWithTopic 

func (base FileDestination) ForEachWithTopic(ctx context.Context, f func(context.Context, *model.FullMessage, string, string, int32) error, ackf, free bool, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (FileDestination) NACK 

func (base FileDestination) NACK(uid utils.MyULID)

func (FileDestination) NACKAll 

func (base FileDestination) NACKAll(msgQ *message.Ring)

func (FileDestination) NACKAllSlice 

func (base FileDestination) NACKAllSlice(msgs []*model.FullMessage)

func (FileDestination) NACKRemaining 

func (base FileDestination) NACKRemaining(msgs []model.OutputMsg)

func (FileDestination) PermError 

func (base FileDestination) PermError(uid utils.MyULID)

func (*FileDestination) Send 

func (d *FileDestination) Send(ctx context.Context, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

type GraylogDestination 

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

func (GraylogDestination) ACK 

func (base GraylogDestination) ACK(uid utils.MyULID)

func (*GraylogDestination) Close 

func (d *GraylogDestination) Close() error

func (GraylogDestination) Fatal 

func (base GraylogDestination) Fatal() chan error

func (GraylogDestination) ForEach 

func (base GraylogDestination) ForEach(ctx context.Context, f func(context.Context, *model.FullMessage) error, ackf, free bool, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (GraylogDestination) ForEachWithTopic 

func (base GraylogDestination) ForEachWithTopic(ctx context.Context, f func(context.Context, *model.FullMessage, string, string, int32) error, ackf, free bool, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (GraylogDestination) NACK 

func (base GraylogDestination) NACK(uid utils.MyULID)

func (GraylogDestination) NACKAll 

func (base GraylogDestination) NACKAll(msgQ *message.Ring)

func (GraylogDestination) NACKAllSlice 

func (base GraylogDestination) NACKAllSlice(msgs []*model.FullMessage)

func (GraylogDestination) NACKRemaining 

func (base GraylogDestination) NACKRemaining(msgs []model.OutputMsg)

func (GraylogDestination) PermError 

func (base GraylogDestination) PermError(uid utils.MyULID)

func (*GraylogDestination) Send 

func (d *GraylogDestination) Send(ctx context.Context, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

type HTTPDestination 

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

func (HTTPDestination) ACK 

func (base HTTPDestination) ACK(uid utils.MyULID)

func (*HTTPDestination) Close 

func (d *HTTPDestination) Close() error

func (HTTPDestination) Fatal 

func (base HTTPDestination) Fatal() chan error

func (HTTPDestination) ForEach 

func (base HTTPDestination) ForEach(ctx context.Context, f func(context.Context, *model.FullMessage) error, ackf, free bool, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (HTTPDestination) ForEachWithTopic 

func (base HTTPDestination) ForEachWithTopic(ctx context.Context, f func(context.Context, *model.FullMessage, string, string, int32) error, ackf, free bool, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (HTTPDestination) NACK 

func (base HTTPDestination) NACK(uid utils.MyULID)

func (HTTPDestination) NACKAll 

func (base HTTPDestination) NACKAll(msgQ *message.Ring)

func (HTTPDestination) NACKAllSlice 

func (base HTTPDestination) NACKAllSlice(msgs []*model.FullMessage)

func (HTTPDestination) NACKRemaining 

func (base HTTPDestination) NACKRemaining(msgs []model.OutputMsg)

func (HTTPDestination) PermError 

func (base HTTPDestination) PermError(uid utils.MyULID)

func (*HTTPDestination) Send 

func (d *HTTPDestination) Send(ctx context.Context, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

type HTTPServerDestination 

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

func (HTTPServerDestination) ACK 

func (base HTTPServerDestination) ACK(uid utils.MyULID)

func (*HTTPServerDestination) Close 

func (d *HTTPServerDestination) Close() (err error)

func (HTTPServerDestination) Fatal 

func (base HTTPServerDestination) Fatal() chan error

func (HTTPServerDestination) ForEach 

func (base HTTPServerDestination) ForEach(ctx context.Context, f func(context.Context, *model.FullMessage) error, ackf, free bool, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (HTTPServerDestination) ForEachWithTopic 

func (base HTTPServerDestination) ForEachWithTopic(ctx context.Context, f func(context.Context, *model.FullMessage, string, string, int32) error, ackf, free bool, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (HTTPServerDestination) NACK 

func (base HTTPServerDestination) NACK(uid utils.MyULID)

func (HTTPServerDestination) NACKAll 

func (base HTTPServerDestination) NACKAll(msgQ *message.Ring)

func (HTTPServerDestination) NACKAllSlice 

func (base HTTPServerDestination) NACKAllSlice(msgs []*model.FullMessage)

func (HTTPServerDestination) NACKRemaining 

func (base HTTPServerDestination) NACKRemaining(msgs []model.OutputMsg)

func (HTTPServerDestination) PermError 

func (base HTTPServerDestination) PermError(uid utils.MyULID)

func (*HTTPServerDestination) Send 

func (d *HTTPServerDestination) Send(ctx context.Context, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (*HTTPServerDestination) ServeHTTP 

func (d *HTTPServerDestination) ServeHTTP(w http.ResponseWriter, r *http.Request)

func (*HTTPServerDestination) Write 

func (d *HTTPServerDestination) Write(p []byte) (n int, err error)

type KafkaDestination 

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

func (KafkaDestination) ACK 

func (base KafkaDestination) ACK(uid utils.MyULID)

func (*KafkaDestination) Close 

func (d *KafkaDestination) Close() error

func (KafkaDestination) Fatal 

func (base KafkaDestination) Fatal() chan error

func (KafkaDestination) ForEach 

func (base KafkaDestination) ForEach(ctx context.Context, f func(context.Context, *model.FullMessage) error, ackf, free bool, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (KafkaDestination) ForEachWithTopic 

func (base KafkaDestination) ForEachWithTopic(ctx context.Context, f func(context.Context, *model.FullMessage, string, string, int32) error, ackf, free bool, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (KafkaDestination) NACK 

func (base KafkaDestination) NACK(uid utils.MyULID)

func (KafkaDestination) NACKAll 

func (base KafkaDestination) NACKAll(msgQ *message.Ring)

func (KafkaDestination) NACKAllSlice 

func (base KafkaDestination) NACKAllSlice(msgs []*model.FullMessage)

func (KafkaDestination) NACKRemaining 

func (base KafkaDestination) NACKRemaining(msgs []model.OutputMsg)

func (KafkaDestination) PermError 

func (base KafkaDestination) PermError(uid utils.MyULID)

func (*KafkaDestination) Send 

func (d *KafkaDestination) Send(ctx context.Context, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

type NATSDestination 

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

func (NATSDestination) ACK 

func (base NATSDestination) ACK(uid utils.MyULID)

func (*NATSDestination) Close 

func (d *NATSDestination) Close() error

func (NATSDestination) Fatal 

func (base NATSDestination) Fatal() chan error

func (NATSDestination) ForEach 

func (base NATSDestination) ForEach(ctx context.Context, f func(context.Context, *model.FullMessage) error, ackf, free bool, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (NATSDestination) ForEachWithTopic 

func (base NATSDestination) ForEachWithTopic(ctx context.Context, f func(context.Context, *model.FullMessage, string, string, int32) error, ackf, free bool, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (NATSDestination) NACK 

func (base NATSDestination) NACK(uid utils.MyULID)

func (NATSDestination) NACKAll 

func (base NATSDestination) NACKAll(msgQ *message.Ring)

func (NATSDestination) NACKAllSlice 

func (base NATSDestination) NACKAllSlice(msgs []*model.FullMessage)

func (NATSDestination) NACKRemaining 

func (base NATSDestination) NACKRemaining(msgs []model.OutputMsg)

func (NATSDestination) PermError 

func (base NATSDestination) PermError(uid utils.MyULID)

func (*NATSDestination) Send 

func (d *NATSDestination) Send(ctx context.Context, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

type RELPDestination 

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

func (RELPDestination) ACK 

func (base RELPDestination) ACK(uid utils.MyULID)

func (*RELPDestination) Close 

func (d *RELPDestination) Close() (err error)

func (RELPDestination) Fatal 

func (base RELPDestination) Fatal() chan error

func (RELPDestination) ForEach 

func (base RELPDestination) ForEach(ctx context.Context, f func(context.Context, *model.FullMessage) error, ackf, free bool, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (RELPDestination) ForEachWithTopic 

func (base RELPDestination) ForEachWithTopic(ctx context.Context, f func(context.Context, *model.FullMessage, string, string, int32) error, ackf, free bool, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (RELPDestination) NACK 

func (base RELPDestination) NACK(uid utils.MyULID)

func (RELPDestination) NACKAll 

func (base RELPDestination) NACKAll(msgQ *message.Ring)

func (RELPDestination) NACKAllSlice 

func (base RELPDestination) NACKAllSlice(msgs []*model.FullMessage)

func (RELPDestination) NACKRemaining 

func (base RELPDestination) NACKRemaining(msgs []model.OutputMsg)

func (RELPDestination) PermError 

func (base RELPDestination) PermError(uid utils.MyULID)

func (*RELPDestination) Send 

func (d *RELPDestination) Send(ctx context.Context, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

type RedisDestination 

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

func (RedisDestination) ACK 

func (base RedisDestination) ACK(uid utils.MyULID)

func (*RedisDestination) Close 

func (d *RedisDestination) Close() error

func (RedisDestination) Fatal 

func (base RedisDestination) Fatal() chan error

func (RedisDestination) ForEach 

func (base RedisDestination) ForEach(ctx context.Context, f func(context.Context, *model.FullMessage) error, ackf, free bool, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (RedisDestination) ForEachWithTopic 

func (base RedisDestination) ForEachWithTopic(ctx context.Context, f func(context.Context, *model.FullMessage, string, string, int32) error, ackf, free bool, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (RedisDestination) NACK 

func (base RedisDestination) NACK(uid utils.MyULID)

func (RedisDestination) NACKAll 

func (base RedisDestination) NACKAll(msgQ *message.Ring)

func (RedisDestination) NACKAllSlice 

func (base RedisDestination) NACKAllSlice(msgs []*model.FullMessage)

func (RedisDestination) NACKRemaining 

func (base RedisDestination) NACKRemaining(msgs []model.OutputMsg)

func (RedisDestination) PermError 

func (base RedisDestination) PermError(uid utils.MyULID)

func (*RedisDestination) Send 

func (d *RedisDestination) Send(ctx context.Context, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

type RemoteClient 

type RemoteClient interface {
	Connect() error
	Close() error
	Send(msg *model.FullMessage) error
	Flush() error
	Ack() *queue.AckQueue
	Nack() *queue.AckQueue
}

type StderrDestination 

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

func (StderrDestination) ACK 

func (base StderrDestination) ACK(uid utils.MyULID)

func (*StderrDestination) Close 

func (d *StderrDestination) Close() error

func (StderrDestination) Fatal 

func (base StderrDestination) Fatal() chan error

func (StderrDestination) ForEach 

func (base StderrDestination) ForEach(ctx context.Context, f func(context.Context, *model.FullMessage) error, ackf, free bool, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (StderrDestination) ForEachWithTopic 

func (base StderrDestination) ForEachWithTopic(ctx context.Context, f func(context.Context, *model.FullMessage, string, string, int32) error, ackf, free bool, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (StderrDestination) NACK 

func (base StderrDestination) NACK(uid utils.MyULID)

func (StderrDestination) NACKAll 

func (base StderrDestination) NACKAll(msgQ *message.Ring)

func (StderrDestination) NACKAllSlice 

func (base StderrDestination) NACKAllSlice(msgs []*model.FullMessage)

func (StderrDestination) NACKRemaining 

func (base StderrDestination) NACKRemaining(msgs []model.OutputMsg)

func (StderrDestination) PermError 

func (base StderrDestination) PermError(uid utils.MyULID)

func (*StderrDestination) Send 

func (d *StderrDestination) Send(ctx context.Context, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

type TCPDestination 

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

func (TCPDestination) ACK 

func (base TCPDestination) ACK(uid utils.MyULID)

func (*TCPDestination) Close 

func (d *TCPDestination) Close() error

func (TCPDestination) Fatal 

func (base TCPDestination) Fatal() chan error

func (TCPDestination) ForEach 

func (base TCPDestination) ForEach(ctx context.Context, f func(context.Context, *model.FullMessage) error, ackf, free bool, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (TCPDestination) ForEachWithTopic 

func (base TCPDestination) ForEachWithTopic(ctx context.Context, f func(context.Context, *model.FullMessage, string, string, int32) error, ackf, free bool, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (TCPDestination) NACK 

func (base TCPDestination) NACK(uid utils.MyULID)

func (TCPDestination) NACKAll 

func (base TCPDestination) NACKAll(msgQ *message.Ring)

func (TCPDestination) NACKAllSlice 

func (base TCPDestination) NACKAllSlice(msgs []*model.FullMessage)

func (TCPDestination) NACKRemaining 

func (base TCPDestination) NACKRemaining(msgs []model.OutputMsg)

func (TCPDestination) PermError 

func (base TCPDestination) PermError(uid utils.MyULID)

func (*TCPDestination) Send 

func (d *TCPDestination) Send(ctx context.Context, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

type UDPDestination 

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

func (UDPDestination) ACK 

func (base UDPDestination) ACK(uid utils.MyULID)

func (*UDPDestination) Close 

func (d *UDPDestination) Close() error

func (UDPDestination) Fatal 

func (base UDPDestination) Fatal() chan error

func (UDPDestination) ForEach 

func (base UDPDestination) ForEach(ctx context.Context, f func(context.Context, *model.FullMessage) error, ackf, free bool, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (UDPDestination) ForEachWithTopic 

func (base UDPDestination) ForEachWithTopic(ctx context.Context, f func(context.Context, *model.FullMessage, string, string, int32) error, ackf, free bool, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (UDPDestination) NACK 

func (base UDPDestination) NACK(uid utils.MyULID)

func (UDPDestination) NACKAll 

func (base UDPDestination) NACKAll(msgQ *message.Ring)

func (UDPDestination) NACKAllSlice 

func (base UDPDestination) NACKAllSlice(msgs []*model.FullMessage)

func (UDPDestination) NACKRemaining 

func (base UDPDestination) NACKRemaining(msgs []model.OutputMsg)

func (UDPDestination) PermError 

func (base UDPDestination) PermError(uid utils.MyULID)

func (*UDPDestination) Send 

func (d *UDPDestination) Send(ctx context.Context, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

type WebsocketServerDestination 

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

func (WebsocketServerDestination) ACK 

func (base WebsocketServerDestination) ACK(uid utils.MyULID)

func (*WebsocketServerDestination) Close 

func (d *WebsocketServerDestination) Close() (err error)

func (WebsocketServerDestination) Fatal 

func (base WebsocketServerDestination) Fatal() chan error

func (WebsocketServerDestination) ForEach 

func (base WebsocketServerDestination) ForEach(ctx context.Context, f func(context.Context, *model.FullMessage) error, ackf, free bool, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (WebsocketServerDestination) ForEachWithTopic 

func (base WebsocketServerDestination) ForEachWithTopic(ctx context.Context, f func(context.Context, *model.FullMessage, string, string, int32) error, ackf, free bool, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

func (WebsocketServerDestination) NACK 

func (base WebsocketServerDestination) NACK(uid utils.MyULID)

func (WebsocketServerDestination) NACKAll 

func (base WebsocketServerDestination) NACKAll(msgQ *message.Ring)

func (WebsocketServerDestination) NACKAllSlice 

func (base WebsocketServerDestination) NACKAllSlice(msgs []*model.FullMessage)

func (WebsocketServerDestination) NACKRemaining 

func (base WebsocketServerDestination) NACKRemaining(msgs []model.OutputMsg)

func (WebsocketServerDestination) PermError 

func (base WebsocketServerDestination) PermError(uid utils.MyULID)

func (*WebsocketServerDestination) Send 

func (d *WebsocketServerDestination) Send(ctx context.Context, msgs []model.OutputMsg) (err eerrors.ErrorSlice)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.