gslog

A gslog.GcpHandler is created with a GCP logging.Logger. The handler will map slog.Record records to logging.Entry entries, subsequently passing the resulting entries to its configured logging.Logger instance's Log() method.

package main

import (
	"context"
	"log/slog"

	"cloud.google.com/go/logging"

	"m4o.io/gslog"
)

func main() {
	ctx := context.Background()
	client, err := logging.NewClient(ctx, "my-project")
	if err != nil {
		// TODO: Handle error.
	}

	lg := client.Logger("my-log")

	lg.Flush()

	h := gslog.NewGcpHandler(lg)
	l := slog.New(h)

	l.Info("How now brown cow?")
}

Output:

A default log level configured via gslog.WithDefaultLogLeveler().

package main

import (
	"encoding/json"
	"fmt"
	"log/slog"

	"cloud.google.com/go/logging"
	"google.golang.org/protobuf/encoding/protojson"

	spb "google.golang.org/protobuf/types/known/structpb"

	"m4o.io/gslog"
)

// PrintJsonPayload is a gslog.Logger stub that prints the logging.Entry
// Payload field as a JSON string.
func PrintJsonPayload(e logging.Entry) {
	b, _ := protojson.Marshal(e.Payload.(*spb.Struct))

	var j map[string]interface{}
	_ = json.Unmarshal(b, &j)
	b, _ = json.Marshal(j)
	fmt.Println(string(b))
}

func main() {
	const envVar = "FOO_LOG_LEVEL"

	h := gslog.NewGcpHandler(
		gslog.LoggerFunc(PrintJsonPayload),
		gslog.WithLogLevelFromEnvVar(envVar),
		gslog.WithDefaultLogLeveler(slog.LevelError),
	)
	l := slog.New(h)

	l.Info("How now brown cow?")
	l.Error("The rain in Spain lies mainly on the plane.")

}

Output:

{"message":"The rain in Spain lies mainly on the plane."}

When configured via k8s.WithPodinfoLabels(), gslog.GcpHandler will include labels from the configured Kubernetes Downward API podinfo labels file to the logging.Entry's Labels field.

The labels are prefixed with "k8s-pod/" to adhere to the Google Cloud Logging conventions for Kubernetes Pod labels.

package main

import (
	"context"
	"fmt"
	"log/slog"
	"sort"
	"strings"

	"cloud.google.com/go/logging"

	"m4o.io/gslog"
	"m4o.io/gslog/k8s"
)

// PrintLabels is a gslog.Logger stub that prints the logging.Entry's
// Labels field.
func PrintLabels(e logging.Entry) {
	keys := make([]string, 0)
	for k := range e.Labels {
		keys = append(keys, k)
	}
	sort.Strings(keys)

	var sb strings.Builder
	for _, k := range keys {
		if sb.Len() > 0 {
			sb.WriteString(", ")
		}
		sb.WriteString(k + "=" + e.Labels[k])
	}

	fmt.Println(sb.String())
}

func main() {
	h := gslog.NewGcpHandler(gslog.LoggerFunc(PrintLabels), k8s.WithPodinfoLabels("k8s/testdata/etc/podinfo"))
	l := slog.New(h)

	ctx := context.Background()
	ctx = gslog.WithLabels(ctx, gslog.Label("a", "one"), gslog.Label("b", "two"))

	l.Log(ctx, gslog.LevelCritical, "Danger, Will Robinson!")

}

Output:

a=one, b=two, k8s-pod/app=hello-world, k8s-pod/environment=stg, k8s-pod/tier=backend, k8s-pod/track=stable

When configured via gslog.WithLogLevelFromEnvVar(), gslog.GcpHandler obtains its log level from tne environmental variable specified by the key.

package main

import (
	"encoding/json"
	"fmt"
	"log/slog"
	"os"

	"cloud.google.com/go/logging"
	"google.golang.org/protobuf/encoding/protojson"

	spb "google.golang.org/protobuf/types/known/structpb"

	"m4o.io/gslog"
)

// PrintJsonPayload is a gslog.Logger stub that prints the logging.Entry
// Payload field as a JSON string.
func PrintJsonPayload(e logging.Entry) {
	b, _ := protojson.Marshal(e.Payload.(*spb.Struct))

	var j map[string]interface{}
	_ = json.Unmarshal(b, &j)
	b, _ = json.Marshal(j)
	fmt.Println(string(b))
}

func main() {
	const envVar = "FOO_LOG_LEVEL"
	_ = os.Setenv(envVar, "ERROR")
	defer func() {
		_ = os.Unsetenv(envVar)
	}()

	h := gslog.NewGcpHandler(gslog.LoggerFunc(PrintJsonPayload), gslog.WithLogLevelFromEnvVar(envVar))
	l := slog.New(h)

	l.Info("How now brown cow?")
	l.Error("The rain in Spain lies mainly on the plane.")

}

Output:

{"message":"The rain in Spain lies mainly on the plane."}

When configured via gslog.WithLogLeveler(), gslog.GcpHandler use the slog.Leveler for logging level enabled checks.

package main

import (
	"encoding/json"
	"fmt"
	"log/slog"

	"cloud.google.com/go/logging"
	"google.golang.org/protobuf/encoding/protojson"

	spb "google.golang.org/protobuf/types/known/structpb"

	"m4o.io/gslog"
)

// PrintJsonPayload is a gslog.Logger stub that prints the logging.Entry
// Payload field as a JSON string.
func PrintJsonPayload(e logging.Entry) {
	b, _ := protojson.Marshal(e.Payload.(*spb.Struct))

	var j map[string]interface{}
	_ = json.Unmarshal(b, &j)
	b, _ = json.Marshal(j)
	fmt.Println(string(b))
}

func main() {
	h := gslog.NewGcpHandler(gslog.LoggerFunc(PrintJsonPayload), gslog.WithLogLeveler(slog.LevelError))
	l := slog.New(h)

	l.Info("How now brown cow?")
	l.Error("The rain in Spain lies mainly on the plane.")

}

Output:

{"message":"The rain in Spain lies mainly on the plane."}

When configured via otel.WithOtelBaggage(), gslog.GcpHandler will include any baggage.Baggage attached to the context as attributes.

The baggage keys are prefixed with "otel-baggage/" to mitigate collision with other log attributes and have precedence over any collisions with preexisting attributes.

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log/slog"

	"cloud.google.com/go/logging"
	"go.opentelemetry.io/otel/baggage"
	"google.golang.org/protobuf/encoding/protojson"

	spb "google.golang.org/protobuf/types/known/structpb"

	"m4o.io/gslog"
	"m4o.io/gslog/otel"
)

// PrintJsonPayload is a gslog.Logger stub that prints the logging.Entry
// Payload field as a JSON string.
func PrintJsonPayload(e logging.Entry) {
	b, _ := protojson.Marshal(e.Payload.(*spb.Struct))

	var j map[string]interface{}
	_ = json.Unmarshal(b, &j)
	b, _ = json.Marshal(j)
	fmt.Println(string(b))
}

func main() {
	h := gslog.NewGcpHandler(gslog.LoggerFunc(PrintJsonPayload), otel.WithOtelBaggage())
	l := slog.New(h)

	ctx := context.Background()
	ctx = baggage.ContextWithBaggage(ctx, otel.MustParse("a=one,b=two;p1;p2=val2"))

	l.Log(ctx, slog.LevelInfo, "How now brown cow?")

}

Output:

{"message":"How now brown cow?","otel-baggage/a":"one","otel-baggage/b":{"properties":{"p1":null,"p2":"val2"},"value":"two"}}

When configured via otel.WithOtelTracing(), gslog.GcpHandler will include any OpenTelemetry trace.SpanContext information associated with the context in the logging.Entry's tracing fields.

package main

import (
	"context"
	"fmt"
	"log/slog"
	"strings"

	"cloud.google.com/go/logging"
	"go.opentelemetry.io/otel/trace"

	"m4o.io/gslog"
	"m4o.io/gslog/otel"
)

// PrintTracing is a gslog.Logger stub that prints the logging.Entry's
// tracing fields.
func PrintTracing(e logging.Entry) {
	var sb strings.Builder

	sb.WriteString("trace: ")
	sb.WriteString(e.Trace)
	sb.WriteString(" span: ")
	sb.WriteString(e.SpanID)
	sb.WriteString(" flags: ")
	if e.TraceSampled {
		sb.WriteString("01")
	} else {
		sb.WriteString("00")
	}

	fmt.Println(sb.String())
}

func main() {
	h := gslog.NewGcpHandler(gslog.LoggerFunc(PrintTracing), otel.WithOtelTracing("my-project"))
	l := slog.New(h)

	traceId, _ := trace.TraceIDFromHex("52fc1643a9381fc674742bb0067101e7")
	spanId, _ := trace.SpanIDFromHex("d3e9e8c51cb190df")

	ctx := context.Background()
	ctx = trace.ContextWithRemoteSpanContext(ctx, trace.NewSpanContext(trace.SpanContextConfig{
		TraceID:    traceId,
		SpanID:     spanId,
		TraceFlags: trace.FlagsSampled,
	}))

	l.Log(ctx, slog.LevelInfo, "How now brown cow?")

}

Output:

trace: projects/my-project/traces/52fc1643a9381fc674742bb0067101e7 span: d3e9e8c51cb190df flags: 01

When configured via gslog.WithReplaceAttr(), gslog.GcpHandler will apply the supplied gslog.AttrMapper to all non-group attributes before they are logged.

package main

import (
	"encoding/json"
	"fmt"
	"log/slog"
	"strconv"

	"cloud.google.com/go/logging"
	"google.golang.org/protobuf/encoding/protojson"

	spb "google.golang.org/protobuf/types/known/structpb"

	"m4o.io/gslog"
)

var (
	pw           = Password("pass-12334")
	pwObfuscated = slog.StringValue("<secret>")
)

type Manager struct{}

// Password is a specialised type whose fmt.Stringer, json.Marshaler, and
// slog.LogValuer implementations return an obfuscated value.
type Password string

func (p Password) String() string {
	return "<secret>"
}

func (p Password) MarshalJSON() ([]byte, error) {
	return []byte(strconv.Quote("<secret>")), nil
}

func (p Password) LogValue() slog.Value {
	return pwObfuscated
}

type User struct {
	ID        string   `json:"id"`
	FirstName string   `json:"first_name"`
	LastName  string   `json:"last_name"`
	Email     string   `json:"email"`
	Password  Password `json:"password"`
	Age       uint8    `json:"age"`
	Height    float32  `json:"height"`
	Engineer  bool     `json:"engineer"`
	Manager   *Manager `json:"manager"`
}

// PrintJsonPayload is a gslog.Logger stub that prints the logging.Entry
// Payload field as a JSON string.
func PrintJsonPayload(e logging.Entry) {
	b, _ := protojson.Marshal(e.Payload.(*spb.Struct))

	var j map[string]interface{}
	_ = json.Unmarshal(b, &j)
	b, _ = json.Marshal(j)
	fmt.Println(string(b))
}

// RemovePassword is a gslog.AttrMapper that elides password attributes.
func RemovePassword(_ []string, a slog.Attr) slog.Attr {
	if a.Key == "password" {
		return slog.Attr{}
	}
	return a
}

func main() {
	h := gslog.NewGcpHandler(gslog.LoggerFunc(PrintJsonPayload), gslog.WithReplaceAttr(RemovePassword))
	l := slog.New(h)
	l = l.WithGroup("pub")
	l = l.With(slog.String("username", "user-12234"), slog.String("password", string(pw)))

	l.Info("How now brown cow?")

}

Output:

{"message":"How now brown cow?","pub":{"username":"user-12234"}}

When configured via gslog.WithSourceAdded(), gslog.GcpHandler will include the computationally expensive SourceLocation field in the logging.Entry.

h := gslog.NewGcpHandler(gslog.LoggerFunc(PrintSourceLocation), gslog.WithSourceAdded())
l := slog.New(h)

l.Log(ctx, slog.LevelInfo, "How now brown cow?")

Output:

{"file":"gslog/example_test.go","function":"m4o.io/gslog_test.ExampleNewGcpHandler_withSourceAdded","line":"259"}