[log] logr.Logger and logr.LogSink Support for controller-runtime Compatibility

go.mod

@@ -10,6 +10,7 @@ require (
 	github.com/fsnotify/fsnotify v1.7.0
 	github.com/getkin/kin-openapi v0.131.0
 	github.com/ghodss/yaml v1.0.0
+	github.com/go-logr/logr v1.4.3
 	github.com/go-resty/resty/v2 v2.11.0
 	github.com/golang-migrate/migrate/v4 v4.17.0
 	github.com/google/uuid v1.5.0

go.sum

@@ -25,6 +25,8 @@ github.com/getkin/kin-openapi v0.131.0 h1:NO2UeHnFKRYhZ8wg6Nyh5Cq7dHk4suQQr72a4p
 github.com/getkin/kin-openapi v0.131.0/go.mod h1:3OlG51PCYNsPByuiMB0t4fjnNlIDnaEDsjiKUV8nL58=
 github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk=
 github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
+github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
+github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-openapi/jsonpointer v0.21.0 h1:YgdVicSA9vH5RiHs9TZW5oyafXZFc6+2Vc1rr/O9oNQ=
 github.com/go-openapi/jsonpointer v0.21.0/go.mod h1:IUyH9l/+uyhIYQ/PXVA41Rexl+kOkAPDdXEYns6fzUY=
 github.com/go-openapi/swag v0.23.0 h1:vsEVJDUo2hPJ2tu0/Xc+4noaxyEffXNIs3cOULZ+GrE=

pkg/eventstreams/eventstreams.go

@@ -243,7 +243,7 @@ func (esm *esManager[CT, DT]) initEventStream(
 		return nil, err
 	}
 
-	streamCtx := log.WithLogField(esm.bgCtx, "eventstream", *spec.ESFields().Name)
+	streamCtx := log.WithLogFields(esm.bgCtx, "eventstream", *spec.ESFields().Name)
 	es = &eventStream[CT, DT]{
 		bgCtx:       streamCtx,
 		esm:         esm,

pkg/ffapi/handler.go

@@ -368,7 +368,7 @@ func (hs *HandlerFactory) APIWrapper(handler HandlerFunction) http.HandlerFunc {
 		}
 		ctx = withRequestID(ctx, httpReqID)
 		ctx = withPassthroughHeaders(ctx, req, hs.PassthroughHeaders)
-		ctx = log.WithLogField(ctx, "httpreq", httpReqID)
+		ctx = log.WithLogFields(ctx, "httpreq", httpReqID)
 
 		req = req.WithContext(ctx)
 		defer cancel()

pkg/ffresty/ffresty.go

@@ -288,7 +288,7 @@ func NewWithConfig(ctx context.Context, ffrestyConfig Config) (client *resty.Cli
 			}
 			rCtx = context.WithValue(rCtx, retryCtxKey{}, r)
 			// Create a request logger from the root logger passed into the client
-			rCtx = log.WithLogField(rCtx, "breq", r.id)
+			rCtx = log.WithLogFields(rCtx, "breq", r.id)
 			req.SetContext(rCtx)
 		}
 

pkg/log/log.go

@@ -1,4 +1,4 @@
-// Copyright © 2022 Kaleido, Inc.
+// Copyright © 2022 - 2025 Kaleido, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
 //
@@ -40,6 +40,7 @@ func WithLogger(ctx context.Context, logger *logrus.Entry) context.Context {
 	return context.WithValue(ctx, ctxLogKey{}, logger)
 }
 
+// Deprecated: Use WithLogFields instead.
 // WithLogField adds the specified field to the logger in the context
 func WithLogField(ctx context.Context, key, value string) context.Context {
 	if len(value) > 61 {
@@ -48,6 +49,37 @@ func WithLogField(ctx context.Context, key, value string) context.Context {
 	return WithLogger(ctx, loggerFromContext(ctx).WithField(key, value))
 }
 
+// WithLogFields adds the specified fields to the logger in the context for structured logging. The key-value pairs must be provided in pairs.
+func WithLogFields(ctx context.Context, keyValues ...string) context.Context {
+	if len(keyValues)%2 != 0 {
+		panic("odd number of key-value entry fields provided, cannot determine key-value pairs")
+	}
+
+	entry := loggerFromContext(ctx)
+	fields := logrus.Fields{}
+	for i := 0; i < len(keyValues); i += 2 {
+		key := keyValues[i]
+		value := keyValues[i+1]
+		if len(value) > 61 {
+			value = value[0:61] + "..."
+		}
+		fields[key] = value
+	}
+	return WithLogger(ctx, entry.WithFields(fields))
+}
+
+// WithFields adds the specified, structured fields to the logger in the context
+func WithFields(ctx context.Context, fields map[string]string) context.Context {
+	entryFields := logrus.Fields{}
+	for key, value := range fields {
+		if len(value) > 61 {
+			value = value[0:61] + "..."
+		}
+		entryFields[key] = value
+	}
+	return WithLogger(ctx, loggerFromContext(ctx).WithFields(entryFields))
+}
+
 // LoggerFromContext returns the logger for the current context, or no logger if there is no context
 func loggerFromContext(ctx context.Context) *logrus.Entry {
 	logger := ctx.Value(ctxLogKey{})

pkg/log/log_test.go

@@ -1,4 +1,4 @@
-// Copyright © 2022 Kaleido, Inc.
+// Copyright © 2022 - 2025 Kaleido, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
 //
@@ -30,7 +30,7 @@ func TestLogContext(t *testing.T) {
 }
 
 func TestLogContextLimited(t *testing.T) {
-	ctx := WithLogField(context.Background(), "myfield", "0123456789012345678901234567890123456789012345678901234567890123456789")
+	ctx := WithLogFields(context.Background(), "myfield", "0123456789012345678901234567890123456789012345678901234567890123456789")
 	assert.Equal(t, "0123456789012345678901234567890123456789012345678901234567890...", L(ctx).Data["myfield"])
 }
 
@@ -82,3 +82,24 @@ func TestSetFormattingJSONEnabled(t *testing.T) {
 
 	L(context.Background()).Infof("JSON logs")
 }
+
+func TestWithFields(t *testing.T) {
+	ctx := WithFields(context.Background(), map[string]string{
+		"myfield": "myvalue",
+		"myfield2": "myvalue2",
+	})
+	assert.Equal(t, "myvalue", L(ctx).Data["myfield"])
+	assert.Equal(t, "myvalue2", L(ctx).Data["myfield2"])
+}
+
+func TestWithLogFields(t *testing.T) {
+	ctx := WithLogFields(context.Background(), "myfield", "myvalue", "myfield2", "myvalue2")
+	assert.Equal(t, "myvalue", L(ctx).Data["myfield"])
+	assert.Equal(t, "myvalue2", L(ctx).Data["myfield2"])
+}
+
+func TestWithLogFieldsOddNumberOfFields(t *testing.T) {
+	assert.Panics(t, func() {
+		WithLogFields(context.Background(), "myfield", "myvalue", "myfield2")
+	})
+}

pkg/log/logr.go

@@ -0,0 +1,114 @@
+// Copyright © 2022 - 2025 Kaleido, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package log
+
+import (
+	"context"
+
+	"github.com/go-logr/logr"
+	"github.com/sirupsen/logrus"
+)
+
+// logr.LogSink duck type backed by firefly-common's logrus wrapper
+type Sink struct {
+	name   string
+	logger *logrus.Entry
+	ctx    context.Context
+}
+
+// NewLogr creates a new logr.Logger backed by firefly-common's logrus wrapper
+func NewLogr(ctx context.Context, name string) logr.Logger {
+	return logr.New(&Sink{
+		name:   name,
+		ctx:    ctx,
+		logger: L(ctx),
+	})
+}
+
+// Init initializes the sink
+func (l *Sink) Init(_ logr.RuntimeInfo) {
+	// Optional: store callDepth if needed
+}
+
+func (l *Sink) Enabled(level int) bool {
+	// Map logr V-levels to ff-common levels
+	// logr: V(0)=info, V(1)=debug, V(2+)=trace
+	switch level {
+	case 0:
+		return l.logger.Level >= logrus.InfoLevel
+	case 1:
+		return l.logger.Level >= logrus.DebugLevel
+	default:
+		return l.logger.Level >= logrus.TraceLevel
+	}
+}
+
+// Info logs an info message with the given keys and values. keysAndValues is not efficiently implemented, use WithValues instead
+func (l *Sink) Info(level int, msg string, keysAndValues ...interface{}) {
+	logger := L(l.buildContext(keysAndValues))
+
+	switch level {
+	case 0:
+		logger.Infof(msg)
+	case 1:
+		logger.Debugf(msg)
+	default:
+		logger.Tracef(msg)
+	}
+}
+
+// Error logs an error message with the given keys and values. keysAndValues is not efficiently implemented, use WithValues instead
+func (l *Sink) Error(err error, msg string, keysAndValues ...interface{}) {
+	logger := L(l.buildContext(keysAndValues))
+	if err != nil {
+		logger = logger.WithError(err)
+	}
+	logger.Errorf(msg)
+}
+
+// WithValues adds the given keys and values to the logger
+func (l *Sink) WithValues(keysAndValues ...interface{}) logr.LogSink {
+	ctx := l.buildContext(keysAndValues)
+	return &Sink{
+		name:   l.name,
+		logger: L(ctx),
+		ctx:    ctx,
+	}
+}
+
+// WithName adds the given name to the logger
+func (l *Sink) WithName(name string) logr.LogSink {
+	newName := l.name
+	if len(newName) > 0 {
+		newName += "."
+	}
+	newName += name
+
+	return &Sink{
+		name:   newName,
+		logger: l.logger.WithField("logger", newName),
+		ctx:    l.ctx,
+	}
+}
+
+func (l *Sink) buildContext(keysAndValues []interface{}) context.Context {
+	fields := make(map[string]string)
+	for i := 0; i < len(keysAndValues); i += 2 {
+		fields[keysAndValues[i].(string)] = keysAndValues[i+1].(string)
+	}
+	return WithFields(l.ctx, fields)
+}

pkg/log/logr_test.go

@@ -0,0 +1,37 @@
+// Copyright © 2022 - 2025 Kaleido, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package log
+
+import (
+	"context"
+	"errors"
+	"testing"
+)
+
+func TestLogr(t *testing.T) {
+	ctx := context.Background()
+	logger := NewLogr(ctx, "test")
+	logger.Info("test", "key", "value")
+
+	subLogger := logger.WithName("sub")
+	subLogger.Info("test", "key", "value")
+
+	subLogger = subLogger.WithValues("key2", "value2")
+	subLogger.Info("test", "key", "value")
+
+	subLogger.V(4).Error(errors.New("test"), "test", "key", "value")
+}

pkg/wsserver/wsconn.go

@@ -48,7 +48,7 @@ type WebSocketCommandMessage struct {
 func newConnection(bgCtx context.Context, server *webSocketServer, conn *ws.Conn) *webSocketConnection {
 	id := fftypes.NewUUID().String()
 	wsc := &webSocketConnection{
-		ctx:     log.WithLogField(bgCtx, "wsc", id),
+		ctx:     log.WithLogFields(bgCtx, "wsc", id),
 		id:      id,
 		server:  server,
 		conn:    conn,