router

type Broadcast ¶

type Broadcast struct {
	core.SimpleRouter `gollumdoc:"embed_type"`
}

Broadcast router

This router implements the default behavior of routing all messages to all producers registered to the configured stream.

Examples

rateLimiter:
  Type: router.Broadcast
  Stream: errorlogs
  Filters:
    - filter.Rate:
      MessagesPerSec: 200

func (router *Broadcast) Configure(conf core.PluginConfigReader)

func (router *Broadcast) Enqueue(msg *core.Message) error

func (router *Broadcast) Start() error

type Distribute ¶

type Distribute struct {
	Broadcast `gollumdoc:"embed_type"`
	// contains filtered or unexported fields
}

Distribute router plugin

The "Distribute" plugin provides 1:n stream remapping by duplicating messages.

During startup, it creates a set of streams with names listed in [TargetStreams]. During execution, it consumes messages from the stream [Stream] and enqueues copies of these messages onto each of the streams listed in [TargetStreams].

When routing to multiple routers, the incoming stream has to be listed explicitly to be used.

Parameters ¶

- TargetStreams: List of streams to route the incoming messages to.

Examples ¶

This example route incoming messages from `streamA` to `streamB` and `streamC` (duplication):

JunkRouterDist:
  Type: router.Distribute
  Stream: streamA
  TargetStreams:
    - streamB
    - streamC

func (router *Distribute) Configure(conf core.PluginConfigReader)

func (router *Distribute) Enqueue(msg *core.Message) error

func (router *Distribute) Start() error

type Metadata ¶

type Metadata struct {
	Broadcast `gollumdoc:"embed_type"`
	// contains filtered or unexported fields
}

Metadata router

This router routes the message to a stream given in a specified metadata field. If the field is not set, the message will be passed along.

Parameters ¶

- Key: The metadata field to read from. By default this parameter is set to "Stream"

Examples

switchRoute:
  Type: router.Metadata
  Stream: errorlogs
  Key: key

func (router *Metadata) Configure(conf core.PluginConfigReader)

func (router *Metadata) Enqueue(msg *core.Message) error

func (router *Metadata) Start() error

type Random ¶

type Random struct {
	core.SimpleRouter `gollumdoc:"embed_type"`
}

Random router plugin

The "Random" router relays each message sent to the stream [Stream] to exactly one of the producers connected to [Stream]. The receiving producer is chosen randomly for each message.

Examples ¶

This example will randomly send messages to one of the two console producers.

randomRouter:
  Type: router.Random
  Stream: randomStream

JunkPrinter00:
  Type: producer.Console
  Streams: randomStream
  Modulators:
    - format.Envelope:
        Prefix: "[junk_00] "

JunkPrinter01:
  Type: producer.Console
  Streams: randomStream
  Modulators:
    - format.Envelope:
        Prefix: "[junk_01] "

func (router *Random) Configure(conf core.PluginConfigReader)

func (router *Random) Enqueue(msg *core.Message) error

func (router *Random) Start() error

type RoundRobin ¶

type RoundRobin struct {
	core.SimpleRouter `gollumdoc:"embed_type"`
	// contains filtered or unexported fields
}

RoundRobin router

This router implements round robin routing. Messages are routed to exactly one of the producers registered to the given stream. The producer is switched in a round robin fashin after each message. This producer can be useful for load balancing, e.g. when the target service does not support sharding by itself.

Examples ¶

This example will send message to the two console producers in an alternating fashin.

loadBalancer:
  Type: router.RoundRobin
  Stream: logs

JunkPrinter00:
  Type: producer.Console
  Streams: randomStream
  Modulators:
    - format.Envelope:
        Prefix: "[junk_00] "

JunkPrinter01:
  Type: producer.Console
  Streams: randomStream
  Modulators:
    - format.Envelope:
        Prefix: "[junk_01] "

func (router *RoundRobin) Configure(conf core.PluginConfigReader)

func (router *RoundRobin) Enqueue(msg *core.Message) error

func (router *RoundRobin) Start() error