reorganize exporters and simplify their use

pkg/exporters/gelf_exporter/config.go

@@ -0,0 +1,42 @@
+package gelfexporter
+
+type config struct {
+	GelfUrl string
+	AppName string
+}
+
+// newConfig creates a validated Config configured with options.
+func newConfig(options ...Option) (config, error) {
+	cfg := config{}
+	for _, opt := range options {
+		cfg = opt.apply(cfg)
+	}
+	return cfg, nil
+}
+
+// Option sets the value of an option for a Config.
+type Option interface {
+	apply(config) config
+}
+
+func WithGelfUrl(url string) Option {
+	return gelfUrlOption(url)
+}
+
+type gelfUrlOption string
+
+func (o gelfUrlOption) apply(cfg config) config {
+	cfg.GelfUrl = string(o)
+	return cfg
+}
+
+func WithAppName(url string) Option {
+	return appName(url)
+}
+
+type appName string
+
+func (o appName) apply(cfg config) config {
+	cfg.AppName = string(o)
+	return cfg
+}

pkg/exporters/gelf_exporter/gelf.go

@@ -0,0 +1,49 @@
+package gelfexporter
+
+import (
+	"fmt"
+	"log"
+
+	"time"
+
+	"git.ma-al.com/gora_filip/pkg/syslog"
+	"gopkg.in/Graylog2/go-gelf.v2/gelf"
+)
+
+type GELFMessage struct {
+	// Name of the application
+	Host string `json:"host"`
+	// Short, descriptive message
+	ShortMessage string `json:"short_message"`
+	// Optional long message.
+	LongMessage string `json:"long_message,omitempty"`
+	// Timestamp in Unix
+	Timestamp time.Time `json:"timestamp"`
+	// Severity level matching Syslog standard.
+	Level syslog.SyslogLevel `json:"level"`
+
+	// All additional field names must start with an underline.
+	ExtraFields map[string]interface{} `json:"extrafields,omitempty"`
+}
+
+func Log(writer *gelf.UDPWriter, msg GELFMessage) {
+	if writer != nil {
+		err := writer.WriteMessage(msg.GELFFormat())
+		if err != nil {
+			log.Println(err)
+		}
+		fmt.Printf("msg: %v sent\n", msg)
+	}
+}
+
+func (g GELFMessage) GELFFormat() *gelf.Message {
+	return &gelf.Message{
+		Version:  "1.1",
+		Host:     g.Host,
+		Short:    g.ShortMessage,
+		Full:     g.LongMessage,
+		TimeUnix: float64(g.Timestamp.Unix()),
+		Level:    int32(g.Level),
+		Extra:    g.ExtraFields,
+	}
+}

pkg/exporters/gelf_exporter/trace.go

@@ -0,0 +1,144 @@
+package gelfexporter
+
+import (
+	"context"
+	"sync"
+
+	"git.ma-al.com/gora_filip/pkg/attr"
+	"git.ma-al.com/gora_filip/pkg/level"
+	"git.ma-al.com/gora_filip/pkg/syslog"
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/sdk/trace"
+	"go.opentelemetry.io/otel/sdk/trace/tracetest"
+	"gopkg.in/Graylog2/go-gelf.v2/gelf"
+)
+
+var _ trace.SpanExporter = &Exporter{}
+
+// New creates an Exporter with the passed options.
+func New(options ...Option) (*Exporter, error) {
+	cfg, err := newConfig(options...)
+	if err != nil {
+		return nil, err
+	}
+
+	writer, err := gelf.NewUDPWriter(cfg.GelfUrl)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Exporter{
+		gelfWriter: writer,
+	}, nil
+
+}
+
+type Exporter struct {
+	gelfWriter *gelf.UDPWriter
+	appName    string
+	stoppedMu  sync.RWMutex
+	stopped    bool
+}
+
+func (e *Exporter) ExportSpans(ctx context.Context, spans []trace.ReadOnlySpan) error {
+	if err := ctx.Err(); err != nil {
+		return err
+	}
+	e.stoppedMu.RLock()
+	stopped := e.stopped
+	e.stoppedMu.RUnlock()
+	if stopped {
+		return nil
+	}
+
+	if len(spans) == 0 {
+		return nil
+	}
+
+	stubs := tracetest.SpanStubsFromReadOnlySpans(spans)
+
+	for i := range stubs {
+		stub := &stubs[i]
+
+		var attributes = make(map[string]interface{})
+		for _, attr := range stub.Attributes {
+			attributes[string(attr.Key)] = GetByType(attr.Value)
+		}
+
+		for i := range stub.Events {
+			event := stub.Events[i]
+
+			var gelf GELFMessage = GELFMessage{
+				Host:         e.appName,
+				ShortMessage: event.Name,
+				Timestamp:    stub.StartTime,
+				// Defaults to ALERT since we consider lack of the level a serious error that should be fixed ASAP.
+				// Otherwise some dangerous unexpected behaviour could go unnoticed.
+				Level:       syslog.ALERT,
+				ExtraFields: attributes,
+			}
+			for _, attrKV := range event.Attributes {
+				if attrKV.Key == "long_message" {
+					gelf.LongMessage = attrKV.Value.AsString()
+					continue
+				}
+
+				if attrKV.Key == attr.SeverityLevelKey {
+					gelf.Level = level.FromString(attrKV.Value.AsString()).IntoSyslogLevel()
+					continue
+				}
+
+				attributes[string(attrKV.Key)] = GetByType(attrKV.Value)
+			}
+
+			Log(e.gelfWriter, gelf)
+		}
+
+	}
+	return nil
+}
+
+func GetByType(val attribute.Value) interface{} {
+	switch val.Type() {
+	case attribute.INVALID:
+		return "invalid value"
+	case attribute.BOOL:
+		return val.AsBool()
+	case attribute.INT64:
+		return val.AsInt64()
+	case attribute.FLOAT64:
+		return val.AsFloat64()
+	case attribute.STRING:
+		return val.AsString()
+	case attribute.BOOLSLICE:
+		return val.AsBoolSlice()
+	case attribute.INT64SLICE:
+		return val.AsInt64Slice()
+	case attribute.FLOAT64SLICE:
+		return val.AsFloat64Slice()
+	case attribute.STRINGSLICE:
+		return val.AsStringSlice()
+	}
+
+	return "invalid value"
+}
+
+// Shutdown is called to stop the exporter, it performs no action.
+func (e *Exporter) Shutdown(ctx context.Context) error {
+	e.stoppedMu.Lock()
+	e.stopped = true
+	e.stoppedMu.Unlock()
+
+	return nil
+}
+
+// // MarshalLog is the marshaling function used by the logging system to represent this Exporter.
+// func (e *Exporter) MarshalLog() interface{} {
+// 	return struct {
+// 		Type           string
+// 		WithTimestamps bool
+// 	}{
+// 		Type:           "stdout",
+// 		WithTimestamps: e.timestamps,
+// 	}
+// }