Sink Interface

The Sink interface is a core component of the go-events library, designed to enable flexible and extensible event handling. Sinks act as destinations for events, allowing for diverse actions like logging, metrics, or external system integration.

Interface Definition:

// Sink defines the interface for handling events.
          type Sink interface {
              // Emit emits the given event to the sink.
              Emit(ctx context.Context, event Event) error
          }
          

Types of Sinks:

• Log Sink: This sink outputs events to a standard logging facility.
  • Usage: go-events provides several built-in log sinks:
    • logrusSink: Emits events to a logrus logger.

      import (
                    "context"
                    "github.com/sirupsen/logrus"
                
                    "github.com/docker/go-events"
                )
                
                func main() {
                    logger := logrus.New()
                    sink := events.NewLogrusSink(logger)
                    emitter := events.NewEmitter(sink)
                
                    emitter.Emit(context.Background(), events.NewEvent("test-event"))
                }
                

    • zapSink: Emits events to a zap logger.

      import (
                    "context"
                    "go.uber.org/zap"
                
                    "github.com/docker/go-events"
                )
                
                func main() {
                    logger, _ := zap.NewProduction()
                    sink := events.NewZapSink(logger)
                    emitter := events.NewEmitter(sink)
                
                    emitter.Emit(context.Background(), events.NewEvent("test-event"))
                }
                

    • stdSink: Emits events to std logger.

      import (
                    "context"
                    "fmt"
                
                    "github.com/docker/go-events"
                )
                
                func main() {
                    sink := events.NewStdSink(fmt.Println)
                    emitter := events.NewEmitter(sink)
                
                    emitter.Emit(context.Background(), events.NewEvent("test-event"))
                }
                

• Metric Sink: This sink pushes events to a metrics system.
  • Usage:
    • prometheusSink: Sends events to a Prometheus server.

      import (
                    "context"
                
                    "github.com/docker/go-events"
                    "github.com/prometheus/client_golang/prometheus"
                )
                
                func main() {
                    counter := prometheus.NewCounter(prometheus.CounterOpts{
                        Name: "test_events_total",
                        Help: "Total number of test events emitted.",
                    })
                    prometheus.MustRegister(counter)
                
                    sink := events.NewPrometheusSink(func(event events.Event) error {
                        counter.Inc()
                        return nil
                    })
                
                    emitter := events.NewEmitter(sink)
                
                    emitter.Emit(context.Background(), events.NewEvent("test-event"))
                }
                

• Custom Sink: Developers can create their own custom sinks to integrate with specific systems or implement custom event handling logic.
  • Example:

    import (
                  "context"
              
                  "github.com/docker/go-events"
              )
              
              type MyCustomSink struct {
                  // Add any necessary fields for your custom sink here
              }
              
              func (s *MyCustomSink) Emit(ctx context.Context, event events.Event) error {
                  // Implement your custom event handling logic here
                  // This example simply prints the event name
                  fmt.Println("Received event:", event.Name)
                  return nil
              }
              
              func main() {
                  sink := &MyCustomSink{}
                  emitter := events.NewEmitter(sink)
              
                  emitter.Emit(context.Background(), events.NewEvent("test-event"))
              }
              

Example Usage:

import (
              "context"
          
              "github.com/docker/go-events"
          )
          
          func main() {
              // Create a new emitter with a log sink
              emitter := events.NewEmitter(events.NewLogrusSink(logrus.New()))
          
              // Emit an event
              emitter.Emit(context.Background(), events.NewEvent("my-event"))
          }
          

Source Code: sink.go