LokI Exporter - Adding a feature for loki exporter to encode JSON for log entry

exporter/lokiexporter/README.md

@@ -44,6 +44,8 @@ The following settings can be optionally configured:
 
 - `headers` (no default): Name/value pairs added to the HTTP request headers.
 
+- `format` (default = body): Set the log entry line format. This can be set to 'json' (the entire json encoded log record) or 'body' (the log record body field as a string).
+
 Example:
 
 ```yaml

exporter/lokiexporter/config.go

@@ -36,6 +36,8 @@ type Config struct {
 
 	// Labels defines how labels should be applied to log streams sent to Loki.
 	Labels LabelsConfig `mapstructure:"labels"`
+	// Allows you to choose the entry format in the exporter
+	Format string `mapstructure:"format"`
 }
 
 func (c *Config) validate() error {

exporter/lokiexporter/config_test.go

@@ -42,7 +42,7 @@ func TestLoadConfig(t *testing.T) {
 	require.NoError(t, err)
 	require.NotNil(t, cfg)
 
-	assert.Equal(t, 2, len(cfg.Exporters))
+	assert.Equal(t, 3, len(cfg.Exporters))
 
 	actualCfg := cfg.Exporters[config.NewIDWithName(typeStr, "allsettings")].(*Config)
 	expectedCfg := Config{
@@ -87,6 +87,59 @@ func TestLoadConfig(t *testing.T) {
 				"severity":      "severity",
 			},
 		},
+		Format: "body",
+	}
+	require.Equal(t, &expectedCfg, actualCfg)
+}
+
+func TestJsonLoadConfig(t *testing.T) {
+	factories, err := componenttest.NopFactories()
+	assert.Nil(t, err)
+
+	factory := NewFactory()
+	factories.Exporters[config.Type(typeStr)] = factory
+	cfg, err := configtest.LoadConfig(path.Join(".", "testdata", "config.yaml"), factories)
+
+	require.NoError(t, err)
+	require.NotNil(t, cfg)
+
+	assert.Equal(t, 3, len(cfg.Exporters))
+
+	actualCfg := cfg.Exporters[config.NewIDWithName(typeStr, "json")].(*Config)
+	expectedCfg := Config{
+		ExporterSettings: config.NewExporterSettings(config.NewIDWithName(typeStr, "json")),
+		HTTPClientSettings: confighttp.HTTPClientSettings{
+			Headers:  map[string]string{},
+			Endpoint: "https://loki:3100/loki/api/v1/push",
+			TLSSetting: configtls.TLSClientSetting{
+				TLSSetting: configtls.TLSSetting{
+					CAFile:   "",
+					CertFile: "",
+					KeyFile:  "",
+				},
+				Insecure: false,
+			},
+			ReadBufferSize:  0,
+			WriteBufferSize: 524288,
+			Timeout:         30000000000,
+		},
+		RetrySettings: exporterhelper.RetrySettings{
+			Enabled:         true,
+			InitialInterval: 5000000000,
+			MaxInterval:     30000000000,
+			MaxElapsedTime:  300000000000,
+		},
+		QueueSettings: exporterhelper.QueueSettings{
+			Enabled:      true,
+			NumConsumers: 10,
+			QueueSize:    5000,
+		},
+		TenantID: "example",
+		Labels: LabelsConfig{
+			Attributes:         map[string]string{},
+			ResourceAttributes: map[string]string{},
+		},
+		Format: "json",
 	}
 	require.Equal(t, &expectedCfg, actualCfg)
 }

exporter/lokiexporter/encode_json.go

@@ -0,0 +1,38 @@
+package lokiexporter
+
+import (
+	"encoding/json"
+
+	"go.opentelemetry.io/collector/consumer/pdata"
+	tracetranslator "go.opentelemetry.io/collector/translator/trace"
+)
+
+// JSON representation of the LogRecord as described by https://developers.google.com/protocol-buffers/docs/proto3#json
+
+type lokiEntry struct {
+	Name       string                 `json:"name,omitempty"`
+	Body       string                 `json:"body,omitempty"`
+	TraceID    string                 `json:"traceid,omitempty"`
+	SpanID     string                 `json:"spanid,omitempty"`
+	Severity   string                 `json:"severity,omitempty"`
+	Attributes map[string]interface{} `json:"attributes,omitempty"`
+}
+
+func encodeJSON(lr pdata.LogRecord) (string, error) {
+	var logRecord lokiEntry
+	var jsonRecord []byte
+
+	logRecord = lokiEntry{
+		Name:       lr.Name(),
+		Body:       lr.Body().StringVal(),
+		TraceID:    lr.TraceID().HexString(),
+		SpanID:     lr.SpanID().HexString(),
+		Severity:   lr.SeverityText(),
+		Attributes: tracetranslator.AttributeMapToMap(lr.Attributes())}
+
+	jsonRecord, err := json.Marshal(logRecord)
+	if err != nil {
+		return "", err
+	}
+	return string(jsonRecord), nil
+}

exporter/lokiexporter/encode_json_test.go

@@ -0,0 +1,35 @@
+package lokiexporter
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"go.opentelemetry.io/collector/consumer/pdata"
+)
+
+func exampleLog() pdata.LogRecord {
+
+	buffer := pdata.NewLogRecord()
+	buffer.Body().SetStringVal("Example log")
+	buffer.SetName("name")
+	buffer.SetSeverityText("error")
+	buffer.Attributes().Insert("attr1", pdata.NewAttributeValueString("1"))
+	buffer.Attributes().Insert("attr2", pdata.NewAttributeValueString("2"))
+	buffer.SetTraceID(pdata.NewTraceID([16]byte{1, 2, 3, 4}))
+	buffer.SetSpanID(pdata.NewSpanID([8]byte{5, 6, 7, 8}))
+
+	return buffer
+}
+
+func exampleJson() string {
+	jsonExample := `{"name":"name","body":"Example log","traceid":"01020304000000000000000000000000","spanid":"0506070800000000","severity":"error","attributes":{"attr1":"1","attr2":"2"}}`
+	return jsonExample
+}
+
+func TestConvert(t *testing.T) {
+	in := exampleJson()
+	out, err := encodeJSON(exampleLog())
+	t.Log(in)
+	t.Log(out, err)
+	assert.Equal(t, in, out)
+}

exporter/lokiexporter/exporter.go

@@ -135,7 +135,19 @@ func (l *lokiExporter) logDataToLoki(ld pdata.Logs) (pr *logproto.PushRequest, n
 					continue
 				}
 				labels := mergedLabels.String()
-				entry := convertLogToLokiEntry(log)
+				var entry *logproto.Entry
+				if l.config.Format == "json" {
+					var err error
+					entry, err = convertLogToJsonEntry(log)
+					if err != nil {
+						// Couldn't convert to JSON so dropping log.
+						numDroppedLogs++
+						l.logger.Error("Failed to convert to JSON - Dropping Log", zap.Error(err))
+						continue
+					}
+				} else {
+					entry = convertLogToLokiEntry(log)
+				}
 
 				if stream, ok := streams[labels]; ok {
 					stream.Entries = append(stream.Entries, *entry)
@@ -201,3 +213,14 @@ func convertLogToLokiEntry(lr pdata.LogRecord) *logproto.Entry {
 		Line:      lr.Body().StringVal(),
 	}
 }
+
+func convertLogToJsonEntry(lr pdata.LogRecord) (*logproto.Entry, error) {
+	line, err := encodeJSON(lr)
+	if err != nil {
+		return nil, err
+	}
+	return &logproto.Entry{
+		Timestamp: time.Unix(0, int64(lr.Timestamp())),
+		Line:      line,
+	}, nil
+}

exporter/lokiexporter/exporter_test.go

@@ -575,3 +575,19 @@ func TestExporter_stopAlwaysReturnsNil(t *testing.T) {
 	require.NotNil(t, exp)
 	require.NoError(t, exp.stop(context.Background()))
 }
+
+func TestExporter_convertLogtoJsonEntry(t *testing.T) {
+	ts := pdata.Timestamp(int64(1) * time.Millisecond.Nanoseconds())
+	lr := pdata.NewLogRecord()
+	lr.Body().SetStringVal("log message")
+	lr.SetTimestamp(ts)
+
+	entry, err := convertLogToJsonEntry(lr)
+	expEntry := &logproto.Entry{
+		Timestamp: time.Unix(0, int64(lr.Timestamp())),
+		Line:      `{"body":"log message"}`,
+	}
+	require.Nil(t, err)
+	require.NotNil(t, entry)
+	require.Equal(t, expEntry, entry)
+}

exporter/lokiexporter/factory.go

@@ -48,6 +48,7 @@ func createDefaultConfig() config.Exporter {
 		RetrySettings: exporterhelper.DefaultRetrySettings(),
 		QueueSettings: exporterhelper.DefaultQueueSettings(),
 		TenantID:      "",
+		Format:        "body",
 		Labels: LabelsConfig{
 			Attributes:         map[string]string{},
 			ResourceAttributes: map[string]string{},

exporter/lokiexporter/testdata/config.yaml

@@ -13,10 +13,15 @@ exporters:
         container.name: "container_name"
         k8s.cluster.name: "k8s_cluster_name"
         severity: "severity"
+  loki/json:
+    endpoint: "https://loki:3100/loki/api/v1/push"
+    tenant_id: "example"
+    format: "json"
   loki/allsettings:
     endpoint: "https://loki:3100/loki/api/v1/push"
     tenant_id: "example"
     insecure: true
+    format: "body"
     ca_file: /var/lib/mycert.pem
     cert_file: certfile
     key_file: keyfile
@@ -47,4 +52,4 @@ service:
     logs:
       receivers: [ nop ]
       processors: [ nop ]
-      exporters: [ loki, loki/allsettings ]
+      exporters: [ loki, loki/allsettings, loki/json ]