Use a public context baggage key

In order to facilitate the deprecation of this library and allow a
smoother migration to other logging libraries, this library will now
store the baggage values in a public key string, which can be read by
anyone, so even if someone sets the key by this deprecated library, we
still can read it by a newer library in another layer.

This is backwards compatible, since we're just making private things
public, except for the unlikely case where the key would collide with
someone other's key.

Author: colega

baggage.go

@@ -6,37 +6,50 @@ import (
 	"fmt"
 	"math/rand"
 	"strconv"
-
-	"github.com/cabify/go-logging/internal"
 )
 
+// BaggageContextKey is the key to be used for the baggage map[string]interface{} in
+// context.*Value.
+// It's intentionally a public string type, so the deprecation of this library is easier, since a public
+// string type can be defined in another package
+var BaggageContextKey interface{} = "logctx-data-map-string-interface"
+
 const loggerRequestIDLength = 7
 
+// Baggage is a handy helper to extract the baggage from the context, probably to be used with another logger
+func Baggage(ctx context.Context) map[string]interface{} {
+	if baggage, ok := ctx.Value(BaggageContextKey).(map[string]interface{}); ok {
+		return baggage
+	}
+
+	return map[string]interface{}{}
+}
+
 // WithBaggageValue returns a context with the added key value pair in the baggage store.
 func WithBaggageValue(ctx context.Context, key, value string) context.Context {
-	oldBaggage, ok := ctx.Value(internal.BaggageContextKey).(internal.Baggage)
+	oldBaggage, ok := ctx.Value(BaggageContextKey).(map[string]interface{})
 
 	if !ok {
-		return context.WithValue(ctx, internal.BaggageContextKey, internal.Baggage{key: value})
+		return context.WithValue(ctx, BaggageContextKey, map[string]interface{}{key: value})
 	}
 
-	newBaggage := make(internal.Baggage, len(oldBaggage)+1)
+	newBaggage := make(map[string]interface{}, len(oldBaggage)+1)
 	for oldKey, oldValue := range oldBaggage {
 		newBaggage[oldKey] = oldValue
 	}
 	newBaggage[key] = value
 
-	return context.WithValue(ctx, internal.BaggageContextKey, newBaggage)
+	return context.WithValue(ctx, BaggageContextKey, newBaggage)
 }
 
 // WithBaggageValues returns a context with all key value pairs added to the baggage store.
 func WithBaggageValues(ctx context.Context, keyValue map[string]string) context.Context {
-	oldBaggage, ok := ctx.Value(internal.BaggageContextKey).(internal.Baggage)
+	oldBaggage, ok := ctx.Value(BaggageContextKey).(map[string]interface{})
 	if !ok {
-		return context.WithValue(ctx, internal.BaggageContextKey, internal.Baggage(keyValue))
+		return context.WithValue(ctx, BaggageContextKey, toMapStringInterface(keyValue))
 	}
 
-	newBaggage := make(internal.Baggage, len(oldBaggage)+len(keyValue))
+	newBaggage := make(map[string]interface{}, len(oldBaggage)+len(keyValue))
 	for oldKey, oldValue := range oldBaggage {
 		newBaggage[oldKey] = oldValue
 	}
@@ -45,16 +58,16 @@ func WithBaggageValues(ctx context.Context, keyValue map[string]string) context.
 		newBaggage[newKey] = newValue
 	}
 
-	return context.WithValue(ctx, internal.BaggageContextKey, newBaggage)
+	return context.WithValue(ctx, BaggageContextKey, newBaggage)
 }
 
 // NewContextWithBaggageFrom returns a new context with baggage values obtained from another context
 func NewContextWithBaggageFrom(ctx context.Context) context.Context {
-	oldBaggage, ok := ctx.Value(internal.BaggageContextKey).(internal.Baggage)
+	oldBaggage, ok := ctx.Value(BaggageContextKey).(map[string]interface{})
 	if !ok {
 		return context.Background()
 	}
-	return context.WithValue(context.Background(), internal.BaggageContextKey, oldBaggage)
+	return context.WithValue(context.Background(), BaggageContextKey, oldBaggage)
 }
 
 // NewContextFromWithValue creates a new context with baggage values from ctx plus the provided one
@@ -71,3 +84,11 @@ func NewID() string {
 	encoded := md5.Sum([]byte(strconv.FormatInt(data, 16)))
 	return fmt.Sprintf("%x", encoded)[:loggerRequestIDLength]
 }
+
+func toMapStringInterface(original map[string]string) map[string]interface{} {
+	m := make(map[string]interface{}, len(original))
+	for k, v := range original {
+		m[k] = v
+	}
+	return m
+}

context_logger.go

@@ -2,15 +2,27 @@ package log
 
 import (
 	"context"
-
-	"github.com/cabify/go-logging/internal"
+	"fmt"
+	"sort"
+	"strings"
 )
 
 type baggageLogger struct {
 	Logger
 	ctx context.Context
 }
 
+func baggageString(b map[string]interface{}) string {
+	var kvPairs []string
+	for key, value := range b {
+		kvPairs = append(kvPairs, fmt.Sprintf("%s:%v", key, value))
+	}
+
+	sort.Strings(kvPairs)
+
+	return strings.Join(kvPairs, ": ")
+}
+
 func newBaggageLogger(ctx context.Context, base Logger) baggageLogger {
 	return baggageLogger{
 		Logger: base,
@@ -19,12 +31,12 @@ func newBaggageLogger(ctx context.Context, base Logger) baggageLogger {
 }
 
 func (l baggageLogger) getContextString() string {
-	baggage, ok := l.ctx.Value(internal.BaggageContextKey).(internal.Baggage)
+	baggage, ok := l.ctx.Value(BaggageContextKey).(map[string]interface{})
 	if !ok {
 		return ""
 	}
 
-	return baggage.String() + ": "
+	return baggageString(baggage) + ": "
 }
 
 func (l baggageLogger) Fatal(args ...interface{}) {

context_logger_interoperability_test.go

@@ -0,0 +1,19 @@
+package log_test
+
+import (
+	"context"
+	"testing"
+
+	log "github.com/cabify/go-logging"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBaggageCanBeReadFromOtherPackages(t *testing.T) {
+	ctx := context.Background()
+	ctx = log.WithBaggageValue(ctx, "key", "value")
+
+	// notice that we're reading using our own key here
+	baggage := ctx.Value("logctx-data-map-string-interface")
+
+	assert.Equal(t, map[string]interface{}{"key": "value"}, baggage)
+}

internal/baggage.go

@@ -6,12 +6,12 @@ package logtest
 import (
 	"context"
 
-	"github.com/cabify/go-logging/internal"
+	log "github.com/cabify/go-logging"
 )
 
 // HasBaggageValue returns whether the context contains a baggage value.
 func HasBaggageValue(ctx context.Context, key, value string) bool {
-	baggage, ok := ctx.Value(internal.BaggageContextKey).(internal.Baggage)
+	baggage, ok := ctx.Value(log.BaggageContextKey).(map[string]interface{})
 	if !ok {
 		return false
 	}