add build tag to disable tracing

* add new build tag `-build=retrynotrace` to support dead code elimination

Author: rashmi-tondare

interceptors/retry/retry.go

@@ -11,7 +11,6 @@ import (
 	"time"
 
 	"github.com/grpc-ecosystem/go-grpc-middleware/v2/metadata"
-	"golang.org/x/net/trace"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	grpcMetadata "google.golang.org/grpc/metadata"
@@ -320,7 +319,7 @@ func contextErrToGrpcErr(err error) error {
 }
 
 func logTrace(ctx context.Context, format string, a ...any) {
-	tr, ok := trace.FromContext(ctx)
+	tr, ok := traceFromCtx(ctx)
 	if !ok {
 		return
 	}

interceptors/retry/trace_notrace.go

@@ -0,0 +1,29 @@
+//go:build retrynotrace
+
+// Copyright (c) The go-grpc-middleware Authors.
+// Licensed under the Apache License 2.0.
+
+package retry
+
+// retrynotrace can be used to avoid importing golang.org/x/net/trace, which in
+// turn enables binaries using go-grpc-middleware for dead code elimination, which can
+// yield improvements in binary size when tracing is not needed.
+
+import (
+	"context"
+	"fmt"
+)
+
+type notrace struct{}
+
+func (notrace) LazyLog(x fmt.Stringer, sensitive bool) {}
+func (notrace) LazyPrintf(format string, a ...any)     {}
+func (notrace) SetError()                              {}
+func (notrace) SetRecycler(f func(any))                {}
+func (notrace) SetTraceInfo(traceID, spanID uint64)    {}
+func (notrace) SetMaxEvents(m int)                     {}
+func (notrace) Finish()                                {}
+
+func traceFromCtx(ctx context.Context) (notrace, bool) {
+	return notrace{}, true
+}

interceptors/retry/trace_notrace_test.go

@@ -0,0 +1,42 @@
+//go:build retrynotrace
+
+// Copyright (c) The go-grpc-middleware Authors.
+// Licensed under the Apache License 2.0.
+
+package retry
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_traceFromCtx(t *testing.T) {
+	tr := notrace{}
+	ctx := context.Background()
+
+	type args struct {
+		ctx context.Context
+	}
+	tests := []struct {
+		name  string
+		args  args
+		want  notrace
+		want1 bool
+	}{
+		{
+			name:  "should return notrace",
+			args:  args{ctx: ctx},
+			want:  tr,
+			want1: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, got1 := traceFromCtx(tt.args.ctx)
+			assert.Equalf(t, tt.want, got, "traceFromCtx(%v)", tt.args.ctx)
+			assert.Equalf(t, tt.want1, got1, "traceFromCtx(%v)", tt.args.ctx)
+		})
+	}
+}

interceptors/retry/trace_withtrace.go

@@ -0,0 +1,16 @@
+//go:build !retrynotrace
+
+// Copyright (c) The go-grpc-middleware Authors.
+// Licensed under the Apache License 2.0.
+
+package retry
+
+import (
+	"context"
+
+	t "golang.org/x/net/trace"
+)
+
+func traceFromCtx(ctx context.Context) (t.Trace, bool) {
+	return t.FromContext(ctx)
+}

interceptors/retry/trace_withtrace_test.go

@@ -0,0 +1,49 @@
+//go:build !retrynotrace
+
+// Copyright (c) The go-grpc-middleware Authors.
+// Licensed under the Apache License 2.0.
+
+package retry
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"golang.org/x/net/trace"
+)
+
+func Test_traceFromCtx(t *testing.T) {
+	tr := trace.New("test", "with trace")
+	ctx := trace.NewContext(context.Background(), tr)
+
+	type args struct {
+		ctx context.Context
+	}
+	tests := []struct {
+		name  string
+		args  args
+		want  trace.Trace
+		want1 bool
+	}{
+		{
+			name:  "should return trace",
+			args:  args{ctx: ctx},
+			want:  tr,
+			want1: true,
+		},
+		{
+			name:  "should return false if trace not found in ctx",
+			args:  args{ctx: context.Background()},
+			want:  nil,
+			want1: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, got1 := traceFromCtx(tt.args.ctx)
+			assert.Equalf(t, tt.want, got, "traceFromCtx(%v)", tt.args.ctx)
+			assert.Equalf(t, tt.want1, got1, "traceFromCtx(%v)", tt.args.ctx)
+		})
+	}
+}