feat(otelgin): Support metrics for otelgin

CHANGELOG.md

@@ -15,6 +15,7 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 - Support yaml/json struct tags for generated code in `go.opentelemetry.io/contrib/config`. (#5433)
 - Add support for parsing YAML configuration via `ParseYAML` in `go.opentelemetry.io/contrib/config`. (#5433)
 - Add support for temporality preference configuration in `go.opentelemetry.io/contrib/config`. (#5860)
+- Support metrics for `go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin`. (#6245)
 
 ### Changed
 

instrumentation/github.com/gin-gonic/gin/otelgin/gintrace.go

@@ -6,14 +6,19 @@
 package otelgin // import "go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin"
 
 import (
+	"bytes"
 	"fmt"
+	"io"
+	"time"
 
 	"github.com/gin-gonic/gin"
 
 	"go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin/internal/semconvutil"
 	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/codes"
+	otelmetric "go.opentelemetry.io/otel/metric"
+	"go.opentelemetry.io/otel/metric/noop"
 	"go.opentelemetry.io/otel/propagation"
 	semconv "go.opentelemetry.io/otel/semconv/v1.20.0"
 	oteltrace "go.opentelemetry.io/otel/trace"
@@ -43,6 +48,56 @@
 	if cfg.Propagators == nil {
 		cfg.Propagators = otel.GetTextMapPropagator()
 	}
+
+	if cfg.MeterProvider == nil {
+		cfg.MeterProvider = otel.GetMeterProvider()
+	}
+	meter := cfg.MeterProvider.Meter(
+		ScopeName,
+		otelmetric.WithInstrumentationVersion(Version()),
+	)
+
+	var err error
+	cfg.reqDuration, err = meter.Float64Histogram("http.server.request.duration",
+		otelmetric.WithDescription("Measures the duration of inbound RPC."),
+		otelmetric.WithUnit("ms"))
+	if err != nil {
+		otel.Handle(err)
+		if cfg.reqDuration == nil {
+			cfg.reqDuration = noop.Float64Histogram{}
+		}
+	}
+
+	cfg.reqSize, err = meter.Int64UpDownCounter("http.server.request.body.size",
+		otelmetric.WithDescription("Measures size of RPC request messages (uncompressed)."),
+		otelmetric.WithUnit("By"))
+	if err != nil {
+		otel.Handle(err)
+		if cfg.reqSize == nil {
+			cfg.reqSize = noop.Int64UpDownCounter{}
+		}
+	}
+
+	cfg.respSize, err = meter.Int64UpDownCounter("http.server.response.body.size",
+		otelmetric.WithDescription("Measures size of RPC response messages (uncompressed)."),
+		otelmetric.WithUnit("By"))
+	if err != nil {
+		otel.Handle(err)
+		if cfg.respSize == nil {
+			cfg.respSize = noop.Int64UpDownCounter{}
+		}
+	}
+
+	cfg.activeReqs, err = meter.Int64UpDownCounter("http.server.active_requests",
+		otelmetric.WithDescription("Measures the number of messages received per RPC. Should be 1 for all non-streaming RPCs."),
+		otelmetric.WithUnit("{count}"))
+	if err != nil {
+		otel.Handle(err)
+		if cfg.activeReqs == nil {
+			cfg.activeReqs = noop.Int64UpDownCounter{}
+		}
+	}
+
 	return func(c *gin.Context) {
 		for _, f := range cfg.Filters {
 			if !f(c.Request) {
@@ -71,6 +126,7 @@
 			oteltrace.WithAttributes(semconv.HTTPRoute(c.FullPath())),
 			oteltrace.WithSpanKind(oteltrace.SpanKindServer),
 		}
+		metricAttrs := semconvutil.HTTPServerRequestMetrics(service, c.Request)
 		var spanName string
 		if cfg.SpanNameFormatter == nil {
 			spanName = c.FullPath()
@@ -79,24 +135,48 @@
 		}
 		if spanName == "" {
 			spanName = fmt.Sprintf("HTTP %s route not found", c.Request.Method)
+		} else {
+			metricAttrs = append(metricAttrs, semconv.HTTPRoute(spanName))
 		}
 		ctx, span := tracer.Start(ctx, spanName, opts...)
 		defer span.End()
 
 		// pass the span through the request context
 		c.Request = c.Request.WithContext(ctx)
+		// calculate the size of the request.
+		reqSize := calcReqSize(c)
+		before := time.Now()
 
 		// serve the request to the next middleware
 		c.Next()
 
+		// Use floating point division here for higher precision (instead of Millisecond method).
+		elapsedTime := float64(time.Since(before)) / float64(time.Millisecond)
+		respSize := c.Writer.Size()
+		// If nothing written in the response yet, a value of -1 may be returned.
+		if respSize < 0 {
+			respSize = 0
+		}
+
 		status := c.Writer.Status()
 		span.SetStatus(semconvutil.HTTPServerStatus(status))
+
+		metricAttrSet := attribute.NewSet(metricAttrs...) // create a set to minimize alloc
+		cfg.reqSize.Add(ctx, int64(reqSize), otelmetric.WithAttributeSet(metricAttrSet))
+		cfg.respSize.Add(ctx, int64(respSize), otelmetric.WithAttributeSet(metricAttrSet))
+
+		extraAttrs := make([]attribute.KeyValue, 0, 2) // pre-alloc cap of 2
 		if status > 0 {
-			span.SetAttributes(semconv.HTTPStatusCode(status))
+			extraAttrs = append(extraAttrs, semconv.HTTPStatusCode(status))
 		}
 		if len(c.Errors) > 0 {
-			span.SetAttributes(attribute.String("gin.errors", c.Errors.String()))
+			extraAttrs = append(extraAttrs, attribute.String("gin.errors", c.Errors.String()))
 		}
+		span.SetAttributes(extraAttrs...) // call set just once
+
+		extraMetricAttrSet := attribute.NewSet(extraAttrs...) // create another set to minimize alloc
+		cfg.reqDuration.Record(ctx, elapsedTime, otelmetric.WithAttributeSet(metricAttrSet), otelmetric.WithAttributeSet(extraMetricAttrSet))
+		cfg.activeReqs.Add(ctx, 1, otelmetric.WithAttributeSet(metricAttrSet), otelmetric.WithAttributeSet(extraMetricAttrSet))
 	}
 }
 
@@ -134,3 +214,30 @@
 	}()
 	c.HTML(code, name, obj)
 }
+
+// calcReqSize returns the total size of the request.
+// It will calculate the header size by iterate all the header KVs
+// and add with body size.
+func calcReqSize(c *gin.Context) int {
+	// Calculate the size of headers
+	headerSize := 0
+	for name, values := range c.Request.Header {
+		headerSize += len(name) + 2 // Colon and space
+		for _, value := range values {
+			headerSize += len(value)
+		}
+	}
+
+	// Read the request body
+	body, err := io.ReadAll(c.Request.Body)
+	if err != nil {
+		// can't read the body, just return the headerSize.
+		return headerSize
+	}
+
+	// Restore the request body for further processing
+	c.Request.Body = io.NopCloser(bytes.NewReader(body))
+
+	// Calculate the total size of the request (headers + body)
+	return headerSize + len(body)
+}

instrumentation/github.com/gin-gonic/gin/otelgin/gintrace_test.go

@@ -6,7 +6,9 @@
 package otelgin
 
 import (
+	"bytes"
 	"context"
+	"io"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -95,3 +97,70 @@ func TestPropagationWithCustomPropagators(t *testing.T) {
 
 	router.ServeHTTP(w, r)
 }
+
+// TestCalcReqSize tests the calcReqSize function.
+func TestCalcReqSize(t *testing.T) {
+	// Create a sample request with a body and headers
+	body := []byte("sample body")
+	req, err := http.NewRequest("POST", "/test", bytes.NewReader(body))
+	if err != nil {
+		t.Fatalf("Failed to create request: %v", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer token")
+
+	// Create a Gin context with the request
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Request = req
+
+	// Call the function to calculate the request size
+	size := calcReqSize(c)
+
+	// Calculate the expected size (body + headers + extra bytes for header formatting)
+	expectedSize := len(body) + len("Content-Type") + len("application/json") + len("Authorization") + len("Bearer token") + 4 // 4 extra bytes for ": " and "\r\n"
+
+	// Check if the calculated size matches the expected size
+	if size != expectedSize {
+		t.Errorf("Expected request size %d, got %d", expectedSize, size)
+	}
+}
+
+// TestCalcReqSizeWithBodyRead tests the calcReqSize function and ensures the request body can still be read afterward.
+func TestCalcReqSizeWithBodyRead(t *testing.T) {
+	// Create a sample request with a body and headers
+	body := []byte("sample body")
+	req, err := http.NewRequest("POST", "/test", bytes.NewReader(body))
+	if err != nil {
+		t.Fatalf("Failed to create request: %v", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer token")
+
+	// Create a Gin context with the request
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	c.Request = req
+
+	// Call the function to calculate the request size
+	size := calcReqSize(c)
+
+	// Calculate the expected size (body + headers + extra bytes for header formatting)
+	expectedSize := len(body) + len("Content-Type") + len("application/json") + len("Authorization") + len("Bearer token") + 4 // 4 extra bytes for ": " and "\r\n"
+
+	// Check if the calculated size matches the expected size
+	if size != expectedSize {
+		t.Errorf("Expected request size %d, got %d", expectedSize, size)
+	}
+
+	// Read the request body again
+	newBody, err := io.ReadAll(c.Request.Body)
+	if err != nil {
+		t.Fatalf("Failed to read request body: %v", err)
+	}
+
+	// Check if the body is unchanged
+	if !bytes.Equal(newBody, body) {
+		t.Errorf("Expected request body %q, got %q", body, newBody)
+	}
+}

instrumentation/github.com/gin-gonic/gin/otelgin/go.mod

@@ -9,39 +9,39 @@ require (
 	github.com/stretchr/testify v1.9.0
 	go.opentelemetry.io/contrib/propagators/b3 v1.30.0
 	go.opentelemetry.io/otel v1.31.0
+	go.opentelemetry.io/otel/metric v1.31.0
 	go.opentelemetry.io/otel/trace v1.31.0
 )
 
 require (
-	github.com/bytedance/sonic v1.12.3 // indirect
-	github.com/bytedance/sonic/loader v0.2.0 // indirect
+	github.com/bytedance/sonic v1.11.6 // indirect
+	github.com/bytedance/sonic/loader v0.1.1 // indirect
 	github.com/cloudwego/base64x v0.1.4 // indirect
 	github.com/cloudwego/iasm v0.2.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/gabriel-vasile/mimetype v1.4.5 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.3 // indirect
 	github.com/gin-contrib/sse v0.1.0 // indirect
 	github.com/go-logr/logr v1.4.2 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/go-playground/locales v0.14.1 // indirect
 	github.com/go-playground/universal-translator v0.18.1 // indirect
-	github.com/go-playground/validator/v10 v10.22.1 // indirect
-	github.com/goccy/go-json v0.10.3 // indirect
+	github.com/go-playground/validator/v10 v10.20.0 // indirect
+	github.com/goccy/go-json v0.10.2 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.8 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
 	github.com/leodido/go-urn v1.4.0 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
-	github.com/pelletier/go-toml/v2 v2.2.3 // indirect
+	github.com/pelletier/go-toml/v2 v2.2.2 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
 	github.com/ugorji/go/codec v1.2.12 // indirect
-	go.opentelemetry.io/otel/metric v1.31.0 // indirect
-	golang.org/x/arch v0.11.0 // indirect
-	golang.org/x/crypto v0.28.0 // indirect
-	golang.org/x/net v0.30.0 // indirect
-	golang.org/x/sys v0.26.0 // indirect
-	golang.org/x/text v0.19.0 // indirect
-	google.golang.org/protobuf v1.35.1 // indirect
+	golang.org/x/arch v0.8.0 // indirect
+	golang.org/x/crypto v0.23.0 // indirect
+	golang.org/x/net v0.25.0 // indirect
+	golang.org/x/sys v0.20.0 // indirect
+	golang.org/x/text v0.15.0 // indirect
+	google.golang.org/protobuf v1.34.1 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )