publisher

Documentation

Index

• type ChanClient
  • func (c ChanClient) PublishEvent(event common.MapStr, opts ...ClientOption) bool
  • func (c ChanClient) PublishEvents(events []common.MapStr, opts ...ClientOption) bool
• type Client
• type ClientOption
  • func Signal(signaler outputs.Signaler) ClientOption
• type Context
  • func Guaranteed(o Context) Context
  • func Sync(o Context) Context
• type ExtChanClient
  • func (c ExtChanClient) PublishEvent(event common.MapStr, opts ...ClientOption) bool
  • func (c ExtChanClient) PublishEvents(events []common.MapStr, opts ...ClientOption) bool
• type PublishMessage
• type PublisherType
  • func New(beatName string, configs map[string]*common.Config, shipper ShipperConfig) (*PublisherType, error)
  • func (publisher *PublisherType) Client() Client
  • func (publisher *PublisherType) GetServerName(ip string) string
  • func (publisher *PublisherType) IsPublisherIP(ip string) bool
  • func (publisher *PublisherType) PublishTopology(params ...string) error
  • func (publisher *PublisherType) RegisterFilter(filters *filter.FilterList) error
  • func (publisher *PublisherType) Stop()
  • func (publisher *PublisherType) UpdateTopologyPeriodically()
• type ShipperConfig
• type Topology
• type TransactionalEventPublisher

Types

type ChanClient

type ChanClient struct {
	Channel chan common.MapStr
}

ChanClient will forward all published events one by one to the given channel

func (ChanClient) PublishEvent

func (c ChanClient) PublishEvent(event common.MapStr, opts ...ClientOption) bool

PublishEvent will publish the event on the channel. Options will be ignored. Always returns true.

func (ChanClient) PublishEvents

func (c ChanClient) PublishEvents(events []common.MapStr, opts ...ClientOption) bool

PublishEvents publishes all event on the configured channel. Options will be ignored. Always returns true.

type Client

type Client interface {
	// 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) Context

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

func Signal

func Signal(signaler outputs.Signaler) ClientOption

type Context

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

func Guaranteed

func Guaranteed(o Context) Context

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

func Sync

func Sync(o Context) Context

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

type ExtChanClient

type ExtChanClient struct {
	Channel chan PublishMessage
}

func (ExtChanClient) PublishEvent

func (c ExtChanClient) PublishEvent(event common.MapStr, opts ...ClientOption) bool

PublishEvent will publish the event on the channel. Options will be ignored. Always returns true.

func (ExtChanClient) PublishEvents

func (c ExtChanClient) PublishEvents(events []common.MapStr, opts ...ClientOption) bool

PublishEvents publishes all event on the configured channel. Options will be ignored. Always returns true.

type PublishMessage

type PublishMessage struct {
	Context Context
	Events  []common.MapStr
}

type PublisherType

type PublisherType struct {
	IpAddrs []string

	Index          string
	Output         []*outputWorker
	TopologyOutput outputs.TopologyOutputer
	IgnoreOutgoing bool
	GeoLite        *libgeo.GeoIP
	Filters        *filter.FilterList

	RefreshTopologyTimer <-chan time.Time
	// contains filtered or unexported fields
}

func New

func New(
	beatName string,
	configs map[string]*common.Config,
	shipper ShipperConfig,
) (*PublisherType, error)

Create new PublisherType

func (*PublisherType) Client

func (publisher *PublisherType) Client() Client

func (*PublisherType) GetServerName

func (publisher *PublisherType) GetServerName(ip string) string

func (*PublisherType) IsPublisherIP

func (publisher *PublisherType) IsPublisherIP(ip string) bool

func (*PublisherType) PublishTopology

func (publisher *PublisherType) PublishTopology(params ...string) error

func (*PublisherType) RegisterFilter

func (publisher *PublisherType) RegisterFilter(filters *filter.FilterList) error

func (*PublisherType) Stop

func (publisher *PublisherType) Stop()

func (*PublisherType) UpdateTopologyPeriodically

func (publisher *PublisherType) UpdateTopologyPeriodically()

type ShipperConfig

type ShipperConfig struct {
	common.EventMetadata `config:",inline"` // Fields and tags to add to each event.
	Name                 string
	RefreshTopologyFreq  time.Duration `config:"refresh_topology_freq"`
	Ignore_outgoing      bool          `config:"ignore_outgoing"`
	Topology_expire      int           `config:"topology_expire"`
	Geoip                common.Geoip  `config:"geoip"`

	// internal publisher queue sizes
	QueueSize     *int `config:"queue_size"`
	BulkQueueSize *int `config:"bulk_queue_size"`
	MaxProcs      *int `config:"max_procs"`
}

type Topology

type Topology struct {
	Name string `json:"name"`
	Ip   string `json:"ip"`
}

type TransactionalEventPublisher

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