publisher

Documentation

Index

• Variables
• type BeatPublisher
  • func New(beat common.BeatInfo, output common.ConfigNamespace, shipper ShipperConfig, ...) (*BeatPublisher, error)
  • func (publisher *BeatPublisher) Connect() Client
  • func (publisher *BeatPublisher) ConnectX(config beat.ClientConfig) (beat.Client, error)
  • func (publisher *BeatPublisher) GetName() string
  • func (publisher *BeatPublisher) SetACKHandler(h beat.PipelineACKHandler) error
  • func (publisher *BeatPublisher) Stop()
• type Client
• type ClientOption
  • func Metadata(m common.MapStr) ClientOption
  • func MetadataBatch(m []common.MapStr) ClientOption
  • func Signal(signaler op.Signaler) ClientOption
• type Context
  • func Guaranteed(o Context) ([]common.MapStr, Context)
  • func MakeContext(opts []ClientOption) ([]common.MapStr, Context)
  • func Sync(o Context) ([]common.MapStr, Context)
• type Publisher
• type ShipperConfig
• type TransactionalEventPublisher

Variables

var (
	ErrClientClosed = errors.New("client closed")
)

Types

type BeatPublisher

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

func New

func New(
	beat common.BeatInfo,
	output common.ConfigNamespace,
	shipper ShipperConfig,
	processors *processors.Processors,
) (*BeatPublisher, error)

Create new PublisherType

func (*BeatPublisher) Connect

func (publisher *BeatPublisher) Connect() Client

func (*BeatPublisher) ConnectX

func (publisher *BeatPublisher) ConnectX(config beat.ClientConfig) (beat.Client, error)

func (*BeatPublisher) GetName

func (publisher *BeatPublisher) GetName() string

func (*BeatPublisher) SetACKHandler

func (publisher *BeatPublisher) SetACKHandler(h beat.PipelineACKHandler) error

func (*BeatPublisher) Stop

func (publisher *BeatPublisher) Stop()

type Client

type Client interface {
	// Close disconnects the Client from the publisher pipeline.
	Close() error

	// PublishEvent publishes one event with given options. If Sync option is set,
	// PublishEvent will block until output plugins report success or failure state
	// being returned by this method.
	PublishEvent(event common.MapStr, opts ...ClientOption) bool

	// PublishEvents publishes multiple events with given options. If Guaranteed
	// option is set, PublishEvent will block until output plugins report
	// success or failure state being returned by this method.
	PublishEvents(events []common.MapStr, opts ...ClientOption) bool
}

Client is used by beats to publish new events.

The publish methods add fields that are common to all events. Both methods add the 'beat' field that contains name and hostname. Also they add 'tags' and 'fields'.

Event publishers can override the default index for an event by adding a 'beat' field whose value is a common.MapStr that contains an 'index' field specifying the destination index.

event := common.MapStr{
    // Setting a custom index for a single event.
    "beat": common.MapStr{"index": "custom-index"},
}

Event publishers can add fields and tags to an event. The fields will take precedence over the global fields defined in the shipper configuration.

event := common.MapStr{
    // Add custom fields to the root of the event.
    common.EventMetadataKey: common.EventMetadata{
        UnderRoot: true,
        Fields:    common.MapStr{"env": "production"}
    }
}

type ClientOption

type ClientOption func(option Context) ([]common.MapStr, Context)

ClientOption allows API users to set additional options when publishing events.

func Metadata

func Metadata(m common.MapStr) ClientOption

func MetadataBatch

func MetadataBatch(m []common.MapStr) ClientOption

func Signal

func Signal(signaler op.Signaler) ClientOption

type Context

type Context struct {
	Signal op.Signaler
	// contains filtered or unexported fields
}

func Guaranteed

func Guaranteed(o Context) ([]common.MapStr, Context)

Guaranteed option will retry publishing the event, until send attempt have been ACKed by output plugin.

func MakeContext

func MakeContext(opts []ClientOption) ([]common.MapStr, Context)

func Sync

func Sync(o Context) ([]common.MapStr, Context)

Sync option will block the event publisher until an event has been ACKed by the output plugin or failed.

type Publisher

type Publisher interface {
	Connect() Client
	ConnectX(beat.ClientConfig) (beat.Client, error)
	SetACKHandler(beat.PipelineACKHandler) error
}

type ShipperConfig

type ShipperConfig struct {
	common.EventMetadata `config:",inline"`     // Fields and tags to add to each event.
	Name                 string                 `config:"name"`
	Queue                common.ConfigNamespace `config:"queue"`

	// internal publisher queue sizes
	MaxProcs *int `config:"max_procs"`
}

type TransactionalEventPublisher

type TransactionalEventPublisher interface {
	PublishTransaction(transaction op.Signaler, events []common.MapStr)
}