[FEATURE] [internal] adds metric collection for graphql queries and resolvers (#354)

* adds metric collection for graphql queries and resolvers

* cleans up graphQL error classification and comments

* fixes go import formatting

Author: aristidesstaffieri

internal/metrics/metrics.go

@@ -36,6 +36,11 @@ type MetricsService interface {
 	ObserveDBTransactionDuration(status string, duration float64)
 	ObserveDBBatchSize(operation, table string, size int)
 	IncSignatureVerificationExpired(expiredSeconds float64)
+	// GraphQL Metrics
+	ObserveGraphQLFieldDuration(operationName, fieldName string, duration float64)
+	IncGraphQLField(operationName, fieldName string, success bool)
+	ObserveGraphQLComplexity(operationName string, complexity int)
+	IncGraphQLError(operationName, errorType string)
 }
 
 // MetricsService handles all metrics for the wallet-backend
@@ -77,6 +82,12 @@ type metricsService struct {
 
 	// Signature Verification Metrics
 	signatureVerificationExpired *prometheus.CounterVec
+
+	// GraphQL Metrics
+	graphqlFieldDuration *prometheus.SummaryVec
+	graphqlFieldsTotal   *prometheus.CounterVec
+	graphqlComplexity    *prometheus.SummaryVec
+	graphqlErrorsTotal   *prometheus.CounterVec
 }
 
 // NewMetricsService creates a new metrics service with all metrics registered
@@ -250,6 +261,38 @@ func NewMetricsService(db *sqlx.DB) MetricsService {
 		[]string{"expired_seconds"},
 	)
 
+	// GraphQL Metrics
+	m.graphqlFieldDuration = prometheus.NewSummaryVec(
+		prometheus.SummaryOpts{
+			Name:       "graphql_field_duration_seconds",
+			Help:       "Duration of GraphQL field resolver execution",
+			Objectives: map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.99: 0.001},
+		},
+		[]string{"operation_name", "field_name"},
+	)
+	m.graphqlFieldsTotal = prometheus.NewCounterVec(
+		prometheus.CounterOpts{
+			Name: "graphql_fields_total",
+			Help: "Total number of GraphQL field resolutions",
+		},
+		[]string{"operation_name", "field_name", "success"},
+	)
+	m.graphqlComplexity = prometheus.NewSummaryVec(
+		prometheus.SummaryOpts{
+			Name:       "graphql_complexity",
+			Help:       "GraphQL query complexity values",
+			Objectives: map[float64]float64{0.5: 0.05, 0.9: 0.01, 0.99: 0.001},
+		},
+		[]string{"operation_name"},
+	)
+	m.graphqlErrorsTotal = prometheus.NewCounterVec(
+		prometheus.CounterOpts{
+			Name: "graphql_errors_total",
+			Help: "Total number of GraphQL errors",
+		},
+		[]string{"operation_name", "error_type"},
+	)
+
 	m.registerMetrics()
 	return m
 }
@@ -279,6 +322,10 @@ func (m *metricsService) registerMetrics() {
 		m.dbTxnDuration,
 		m.dbBatchSize,
 		m.signatureVerificationExpired,
+		m.graphqlFieldDuration,
+		m.graphqlFieldsTotal,
+		m.graphqlComplexity,
+		m.graphqlErrorsTotal,
 	)
 }
 
@@ -466,3 +513,24 @@ func (m *metricsService) ObserveDBBatchSize(operation, table string, size int) {
 func (m *metricsService) IncSignatureVerificationExpired(expiredSeconds float64) {
 	m.signatureVerificationExpired.WithLabelValues(fmt.Sprintf("%fs", expiredSeconds)).Inc()
 }
+
+// GraphQL Metrics
+func (m *metricsService) ObserveGraphQLFieldDuration(operationName, fieldName string, duration float64) {
+	m.graphqlFieldDuration.WithLabelValues(operationName, fieldName).Observe(duration)
+}
+
+func (m *metricsService) IncGraphQLField(operationName, fieldName string, success bool) {
+	successStr := "true"
+	if !success {
+		successStr = "false"
+	}
+	m.graphqlFieldsTotal.WithLabelValues(operationName, fieldName, successStr).Inc()
+}
+
+func (m *metricsService) ObserveGraphQLComplexity(operationName string, complexity int) {
+	m.graphqlComplexity.WithLabelValues(operationName).Observe(float64(complexity))
+}
+
+func (m *metricsService) IncGraphQLError(operationName, errorType string) {
+	m.graphqlErrorsTotal.WithLabelValues(operationName, errorType).Inc()
+}

internal/metrics/mocks.go

@@ -112,3 +112,19 @@ func (m *MockMetricsService) ObserveDBBatchSize(operation, table string, size in
 func (m *MockMetricsService) IncSignatureVerificationExpired(expiredSeconds float64) {
 	m.Called(expiredSeconds)
 }
+
+func (m *MockMetricsService) ObserveGraphQLFieldDuration(operationName, fieldName string, duration float64) {
+	m.Called(operationName, fieldName, duration)
+}
+
+func (m *MockMetricsService) IncGraphQLField(operationName, fieldName string, success bool) {
+	m.Called(operationName, fieldName, success)
+}
+
+func (m *MockMetricsService) ObserveGraphQLComplexity(operationName string, complexity int) {
+	m.Called(operationName, complexity)
+}
+
+func (m *MockMetricsService) IncGraphQLError(operationName, errorType string) {
+	m.Called(operationName, errorType)
+}

internal/serve/graphql/resolvers/resolver.go

@@ -20,6 +20,7 @@ import (
 	"github.com/stellar/wallet-backend/internal/data"
 	"github.com/stellar/wallet-backend/internal/entities"
 	"github.com/stellar/wallet-backend/internal/indexer/types"
+	"github.com/stellar/wallet-backend/internal/metrics"
 	"github.com/stellar/wallet-backend/internal/serve/graphql/dataloaders"
 	graphql1 "github.com/stellar/wallet-backend/internal/serve/graphql/generated"
 	"github.com/stellar/wallet-backend/internal/serve/middleware"
@@ -41,17 +42,20 @@ type Resolver struct {
 	transactionService services.TransactionService
 	// feeBumpService provides fee-bump transaction wrapping operations
 	feeBumpService services.FeeBumpService
+	// metricsService provides metrics collection capabilities
+	metricsService metrics.MetricsService
 }
 
 // NewResolver creates a new resolver instance with required dependencies
 // This constructor is called during server startup to initialize the resolver
 // Dependencies are injected here and available to all resolver functions.
-func NewResolver(models *data.Models, accountService services.AccountService, transactionService services.TransactionService, feeBumpService services.FeeBumpService) *Resolver {
+func NewResolver(models *data.Models, accountService services.AccountService, transactionService services.TransactionService, feeBumpService services.FeeBumpService, metricsService metrics.MetricsService) *Resolver {
 	return &Resolver{
 		models:             models,
 		accountService:     accountService,
 		transactionService: transactionService,
 		feeBumpService:     feeBumpService,
+		metricsService:     metricsService,
 	}
 }
 

internal/serve/middleware/complexity_logger.go

@@ -6,18 +6,25 @@ import (
 	"context"
 
 	"github.com/stellar/go/support/log"
+
+	"github.com/stellar/wallet-backend/internal/metrics"
 )
 
 // ComplexityLogger implements the gqlgen-complexity-reporter interface
 // to log GraphQL query complexity values for monitoring and debugging.
-type ComplexityLogger struct{}
+// It also emits Prometheus metrics for query complexity.
+type ComplexityLogger struct {
+	metricsService metrics.MetricsService
+}
 
 // NewComplexityLogger creates a new complexity logger instance.
-func NewComplexityLogger() *ComplexityLogger {
-	return &ComplexityLogger{}
+func NewComplexityLogger(metricsService metrics.MetricsService) *ComplexityLogger {
+	return &ComplexityLogger{
+		metricsService: metricsService,
+	}
 }
 
-// ReportComplexity logs the complexity of a GraphQL query.
+// ReportComplexity logs the complexity of a GraphQL query and records it to Prometheus.
 // This method is called by the gqlgen-complexity-reporter extension.
 func (c *ComplexityLogger) ReportComplexity(ctx context.Context, operationName string, complexity int) {
 	logger := log.Ctx(ctx)
@@ -29,4 +36,6 @@ func (c *ComplexityLogger) ReportComplexity(ctx context.Context, operationName s
 	logger.WithField("operation_name", operationName).
 		WithField("complexity", complexity).
 		Info("graphql query complexity")
+
+	c.metricsService.ObserveGraphQLComplexity(operationName, complexity)
 }

internal/serve/middleware/graphql_field_metrics.go

@@ -0,0 +1,89 @@
+package middleware
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"github.com/99designs/gqlgen/graphql"
+	"github.com/vektah/gqlparser/v2/gqlerror"
+
+	"github.com/stellar/wallet-backend/internal/metrics"
+)
+
+// GraphQLFieldMetrics tracks metrics for individual GraphQL field resolvers.
+// It measures field execution duration, counts resolutions, and tracks errors.
+type GraphQLFieldMetrics struct {
+	metricsService metrics.MetricsService
+}
+
+// NewGraphQLFieldMetrics creates a new GraphQL field metrics middleware.
+func NewGraphQLFieldMetrics(metricsService metrics.MetricsService) *GraphQLFieldMetrics {
+	return &GraphQLFieldMetrics{
+		metricsService: metricsService,
+	}
+}
+
+// Middleware is the field middleware function that wraps field resolver execution.
+// It measures execution time and tracks success/failure for each field resolution.
+func (m *GraphQLFieldMetrics) Middleware(ctx context.Context, next graphql.Resolver) (interface{}, error) {
+	// Get the field context to extract operation and field information
+	fc := graphql.GetFieldContext(ctx)
+	if fc == nil {
+		// If we can't get field context, just pass through
+		return next(ctx)
+	}
+
+	oc := graphql.GetOperationContext(ctx)
+	operationName := "<unnamed>"
+	if oc != nil && oc.OperationName != "" {
+		operationName = oc.OperationName
+	}
+
+	fieldName := fc.Field.Name
+
+	startTime := time.Now()
+	res, err := next(ctx)
+	duration := time.Since(startTime).Seconds()
+	m.metricsService.ObserveGraphQLFieldDuration(operationName, fieldName, duration)
+
+	success := err == nil
+	m.metricsService.IncGraphQLField(operationName, fieldName, success)
+
+	if err != nil {
+		errorType := classifyGraphQLError(err)
+		m.metricsService.IncGraphQLError(operationName, errorType)
+	}
+
+	return res, err
+}
+
+// classifyGraphQLError determines the error type from a GraphQL error.
+// It inspects error extensions and error structure to categorize the error.
+func classifyGraphQLError(err error) string {
+	var gqlErr *gqlerror.Error
+	if errors.As(err, &gqlErr) {
+		if gqlErr.Extensions != nil {
+			if code, ok := gqlErr.Extensions["code"].(string); ok {
+				switch code {
+				case "GRAPHQL_VALIDATION_FAILED":
+					return "validation_error"
+				case "GRAPHQL_PARSE_FAILED":
+					return "parse_error"
+				case "BAD_USER_INPUT":
+					return "bad_input"
+				case "UNAUTHENTICATED":
+					return "auth_error"
+				case "FORBIDDEN":
+					return "forbidden"
+				case "INTERNAL_SERVER_ERROR":
+					return "internal_error"
+				default:
+					return code
+				}
+			}
+		}
+	}
+
+	return "unknown"
+}

internal/serve/serve.go

@@ -231,7 +231,7 @@ func handler(deps handlerDeps) http.Handler {
 		r.Route("/graphql", func(r chi.Router) {
 			r.Use(middleware.DataloaderMiddleware(deps.Models))
 
-			resolver := resolvers.NewResolver(deps.Models, deps.AccountService, deps.TransactionService, deps.FeeBumpService)
+			resolver := resolvers.NewResolver(deps.Models, deps.AccountService, deps.TransactionService, deps.FeeBumpService, deps.MetricsService)
 
 			config := generated.Config{
 				Resolvers: resolver,
@@ -254,9 +254,13 @@ func handler(deps handlerDeps) http.Handler {
 			srv.Use(extension.FixedComplexityLimit(deps.GraphQLComplexityLimit))
 
 			// Add complexity logging - reports all queries with their complexity values
-			reporter := middleware.NewComplexityLogger()
+			reporter := middleware.NewComplexityLogger(deps.MetricsService)
 			srv.Use(complexityreporter.NewExtension(reporter))
 
+			// Add field-level metrics tracking
+			fieldMetrics := middleware.NewGraphQLFieldMetrics(deps.MetricsService)
+			srv.AroundFields(fieldMetrics.Middleware)
+
 			r.Handle("/query", srv)
 		})
 	})