2554 Enhance REST OTEL instrumentation with custom metrics and traces

src/Core/Resolvers/SqlQueryEngine.cs

@@ -332,6 +332,7 @@ public object ResolveList(JsonElement array, IObjectField fieldSchema, ref IMeta
                     JsonElement result = await _cache.GetOrSetAsync<JsonElement>(queryExecutor, queryMetadata, cacheEntryTtl: runtimeConfig.GetEntityCacheEntryTtl(entityName: structure.EntityName));
                     byte[] jsonBytes = JsonSerializer.SerializeToUtf8Bytes(result);
                     JsonDocument cacheServiceResponse = JsonDocument.Parse(jsonBytes);
+
                     return cacheServiceResponse;
                 }
             }
@@ -348,6 +349,7 @@ public object ResolveList(JsonElement array, IObjectField fieldSchema, ref IMeta
                 httpContext: _httpContextAccessor.HttpContext!,
                 args: null,
                 dataSourceName: dataSourceName);
+
             return response;
         }
 

src/Service.Tests/Configuration/OpenTelemetryTests.cs

@@ -61,7 +61,6 @@ public void CleanUpTelemetryConfig()
             File.Delete(CONFIG_WITHOUT_TELEMETRY);
         }
 
-        Startup.OpenTelemetryOptions = new();
     }
 
     /// <summary>

src/Service/Azure.DataApiBuilder.Service.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk.Web">
+<Project Sdk="Microsoft.NET.Sdk.Web">
 
     <PropertyGroup>
         <TargetFrameworks>net8.0</TargetFrameworks>
@@ -77,7 +77,7 @@
         <PackageReference Include="System.CommandLine" />
         <PackageReference Include="System.IO.Abstractions" />
         <PackageReference Include="ZiggyCreatures.FusionCache" />
-        <PackageReference Include="OpenTelemetry.Exporter.OpenTelemetryProtocol"  />
+        <PackageReference Include="OpenTelemetry.Exporter.OpenTelemetryProtocol" />
         <PackageReference Include="OpenTelemetry.Extensions.Hosting" />
         <PackageReference Include="OpenTelemetry.Instrumentation.AspNetCore" />
         <PackageReference Include="OpenTelemetry.Instrumentation.Http" />

src/Service/Controllers/RestController.cs

@@ -2,13 +2,16 @@
 // Licensed under the MIT License.
 
 using System;
+using System.Diagnostics;
 using System.Net;
 using System.Net.Mime;
 using System.Threading.Tasks;
 using Azure.DataApiBuilder.Config.ObjectModel;
+using Azure.DataApiBuilder.Core.Configurations;
 using Azure.DataApiBuilder.Core.Models;
 using Azure.DataApiBuilder.Core.Services;
 using Azure.DataApiBuilder.Service.Exceptions;
+using Azure.DataApiBuilder.Service.Telemetry;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Logging;
@@ -47,11 +50,14 @@ public class RestController : ControllerBase
 
         private readonly ILogger<RestController> _logger;
 
+        private readonly RuntimeConfigProvider _runtimeConfigProvider;
+
         /// <summary>
         /// Constructor.
         /// </summary>
-        public RestController(RestService restService, IOpenApiDocumentor openApiDocumentor, ILogger<RestController> logger)
+        public RestController(RuntimeConfigProvider runtimeConfigProvider, RestService restService, IOpenApiDocumentor openApiDocumentor, ILogger<RestController> logger)
         {
+            _runtimeConfigProvider = runtimeConfigProvider;
             _restService = restService;
             _openApiDocumentor = openApiDocumentor;
             _logger = logger;
@@ -185,8 +191,25 @@ private async Task<IActionResult> HandleOperation(
             string route,
             EntityActionOperation operationType)
         {
+            Stopwatch stopwatch = Stopwatch.StartNew();
+            // This activity tracks the entire REST request.
+            using Activity? activity = TelemetryTracesHelper.DABActivitySource.StartActivity($"{HttpContext.Request.Method} {(route.Split('/').Length > 1 ? route.Split('/')[1] : "")}");
+            if (activity is not null)
+            {
+                activity.TrackRestControllerActivityStarted(
+                    HttpContext.Request.Method,
+                    HttpContext.Request.Headers["User-Agent"].ToString(),
+                    operationType.ToString(),
+                    route,
+                    HttpContext.Request.QueryString.ToString(),
+                    HttpContext.User.FindFirst("role")?.Value,
+                    "REST");
+            }
+
+            TelemetryMetricsHelper.IncrementActiveRequests();
             try
             {
+
                 if (route.Equals(REDIRECTED_ROUTE))
                 {
                     return NotFound();
@@ -208,8 +231,26 @@ private async Task<IActionResult> HandleOperation(
 
                 (string entityName, string primaryKeyRoute) = _restService.GetEntityNameAndPrimaryKeyRouteFromRoute(routeAfterPathBase);
 
+                // This activity tracks the query execution. This will create a new activity nested under the REST request activity.
+                using Activity? queryActivity = TelemetryTracesHelper.DABActivitySource.StartActivity($"QUERY {entityName}");
                 IActionResult? result = await _restService.ExecuteAsync(entityName, operationType, primaryKeyRoute);
 
+                RuntimeConfig runtimeConfig = _runtimeConfigProvider.GetConfig();
+                string dataSourceName = runtimeConfig.GetDataSourceNameFromEntityName(entityName);
+                DatabaseType databaseType = runtimeConfig.GetDataSourceFromDataSourceName(dataSourceName).DatabaseType;
+
+                if (queryActivity is not null)
+                {
+                    queryActivity.TrackQueryActivityStarted(
+                        databaseType.ToString(),
+                        dataSourceName);
+                }
+
+                if (queryActivity is not null && queryActivity.IsAllDataRequested)
+                {
+                    queryActivity.Dispose();
+                }
+
                 if (result is null)
                 {
                     throw new DataApiBuilderException(
@@ -218,6 +259,13 @@ private async Task<IActionResult> HandleOperation(
                         subStatusCode: DataApiBuilderException.SubStatusCodes.EntityNotFound);
                 }
 
+                int statusCode = (result as ObjectResult)?.StatusCode ?? (result as StatusCodeResult)?.StatusCode ?? (result as JsonResult)?.StatusCode ?? 200;
+                if (activity is not null && activity.IsAllDataRequested)
+                {
+                    activity.TrackRestControllerActivityFinished(statusCode);
+                }
+
+                TelemetryMetricsHelper.TrackRequest(HttpContext.Request.Method, statusCode, route, "REST");
                 return result;
             }
             catch (DataApiBuilderException ex)
@@ -228,6 +276,9 @@ private async Task<IActionResult> HandleOperation(
                     HttpContextExtensions.GetLoggerCorrelationId(HttpContext));
 
                 Response.StatusCode = (int)ex.StatusCode;
+                activity?.TrackRestControllerActivityFinishedWithWithException(ex, Response.StatusCode);
+
+                TelemetryMetricsHelper.TrackError(HttpContext.Request.Method, Response.StatusCode, route, "REST", ex);
                 return ErrorResponse(ex.SubStatusCode.ToString(), ex.Message, ex.StatusCode);
             }
             catch (Exception ex)
@@ -238,11 +289,25 @@ private async Task<IActionResult> HandleOperation(
                     HttpContextExtensions.GetLoggerCorrelationId(HttpContext));
 
                 Response.StatusCode = (int)HttpStatusCode.InternalServerError;
+                activity?.TrackRestControllerActivityFinishedWithWithException(ex, Response.StatusCode);
+
+                TelemetryMetricsHelper.TrackError(HttpContext.Request.Method, Response.StatusCode, route, "REST", ex);
                 return ErrorResponse(
                     DataApiBuilderException.SubStatusCodes.UnexpectedError.ToString(),
                     SERVER_ERROR,
                     HttpStatusCode.InternalServerError);
             }
+            finally
+            {
+                stopwatch.Stop();
+                TelemetryMetricsHelper.TrackRequestDuration(HttpContext.Request.Method, Response.StatusCode, route, "REST", stopwatch.Elapsed.TotalMilliseconds);
+                if (activity is not null && activity.IsAllDataRequested)
+                {
+                    activity.Dispose();
+                }
+
+                TelemetryMetricsHelper.DecrementActiveRequests();
+            }
         }
 
         /// <summary>

src/Service/Program.cs

@@ -17,9 +17,6 @@
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.ApplicationInsights;
-using OpenTelemetry.Exporter;
-using OpenTelemetry.Logs;
-using OpenTelemetry.Resources;
 
 namespace Azure.DataApiBuilder.Service
 {
@@ -178,22 +175,6 @@ public static ILoggerFactory GetLoggerFactoryForLogLevel(LogLevel logLevel, Tele
                         }
                     }
 
-                    if (Startup.OpenTelemetryOptions.Enabled && !string.IsNullOrWhiteSpace(Startup.OpenTelemetryOptions.Endpoint))
-                    {
-                        builder.AddOpenTelemetry(logging =>
-                        {
-                            logging.IncludeFormattedMessage = true;
-                            logging.IncludeScopes = true;
-                            logging.SetResourceBuilder(ResourceBuilder.CreateDefault().AddService(Startup.OpenTelemetryOptions.ServiceName!));
-                            logging.AddOtlpExporter(configure =>
-                            {
-                                configure.Endpoint = new Uri(Startup.OpenTelemetryOptions.Endpoint);
-                                configure.Headers = Startup.OpenTelemetryOptions.Headers;
-                                configure.Protocol = OtlpExportProtocol.Grpc;
-                            });
-                        });
-                    }
-
                     builder.AddConsole();
                 });
         }

src/Service/Startup.cs

@@ -61,7 +61,6 @@ public class Startup
         public static LogLevel MinimumLogLevel = LogLevel.Error;
 
         public static bool IsLogLevelOverriddenByCli;
-        public static OpenTelemetryOptions OpenTelemetryOptions = new();
 
         public static ApplicationInsightsOptions AppInsightsOptions = new();
         public const string NO_HTTPS_REDIRECT_FLAG = "--no-https-redirect";
@@ -119,31 +118,46 @@ public void ConfigureServices(IServiceCollection services)
                 && runtimeConfig?.Runtime?.Telemetry?.OpenTelemetry is not null
                 && runtimeConfig.Runtime.Telemetry.OpenTelemetry.Enabled)
             {
+                services.Configure<OpenTelemetryLoggerOptions>(options =>
+                {
+                    options.IncludeScopes = true;
+                    options.ParseStateValues = true;
+                    options.IncludeFormattedMessage = true;
+                });
                 services.AddOpenTelemetry()
+                .WithLogging(logging =>
+                {
+                    logging.SetResourceBuilder(ResourceBuilder.CreateDefault().AddService(runtimeConfig.Runtime.Telemetry.OpenTelemetry.ServiceName!))
+                    .AddOtlpExporter(configure =>
+                    {
+                        configure.Endpoint = new Uri(runtimeConfig.Runtime.Telemetry.OpenTelemetry.Endpoint!);
+                        configure.Headers = runtimeConfig.Runtime.Telemetry.OpenTelemetry.Headers;
+                        configure.Protocol = OtlpExportProtocol.Grpc;
+                    });
+
+                })
                 .WithMetrics(metrics =>
                 {
                     metrics.SetResourceBuilder(ResourceBuilder.CreateDefault().AddService(runtimeConfig.Runtime.Telemetry.OpenTelemetry.ServiceName!))
-                        .AddAspNetCoreInstrumentation()
-                        .AddHttpClientInstrumentation()
                         .AddOtlpExporter(configure =>
                         {
                             configure.Endpoint = new Uri(runtimeConfig.Runtime.Telemetry.OpenTelemetry.Endpoint!);
                             configure.Headers = runtimeConfig.Runtime.Telemetry.OpenTelemetry.Headers;
                             configure.Protocol = OtlpExportProtocol.Grpc;
                         })
-                        .AddRuntimeInstrumentation();
+                        .AddMeter(TelemetryMetricsHelper.MeterName);
                 })
                 .WithTracing(tracing =>
                 {
                     tracing.SetResourceBuilder(ResourceBuilder.CreateDefault().AddService(runtimeConfig.Runtime.Telemetry.OpenTelemetry.ServiceName!))
-                        .AddAspNetCoreInstrumentation()
                         .AddHttpClientInstrumentation()
                         .AddOtlpExporter(configure =>
                         {
                             configure.Endpoint = new Uri(runtimeConfig.Runtime.Telemetry.OpenTelemetry.Endpoint!);
                             configure.Headers = runtimeConfig.Runtime.Telemetry.OpenTelemetry.Headers;
                             configure.Protocol = OtlpExportProtocol.Grpc;
-                        });
+                        })
+                        .AddSource(TelemetryTracesHelper.DABActivitySource.Name);
                 });
             }
 

src/Service/Telemetry/TelemetryMetricsHelper.cs

@@ -0,0 +1,77 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+using System.Diagnostics.Metrics;
+
+namespace Azure.DataApiBuilder.Service.Telemetry
+{
+    /// <summary>
+    /// Helper class for tracking telemetry metrics such as active requests, errors, total requests,
+    /// and request durations using the .NET Meter and Counter APIs.
+    /// </summary>
+    public static class TelemetryMetricsHelper
+    {
+        public static readonly string MeterName = "DataApiBuilder.Metrics";
+        private static readonly Meter _meter = new(MeterName);
+        private static readonly UpDownCounter<long> _activeRequests = _meter.CreateUpDownCounter<long>("active_requests");
+        private static readonly Counter<long> _errorCounter = _meter.CreateCounter<long>("total_errors");
+        private static readonly Counter<long> _totalRequests = _meter.CreateCounter<long>("total_requests");
+        private static readonly Histogram<double> _requestDuration = _meter.CreateHistogram<double>("request_duration", "ms");
+
+        public static void IncrementActiveRequests() => _activeRequests.Add(1);
+
+        public static void DecrementActiveRequests() => _activeRequests.Add(-1);
+
+        /// <summary>
+        /// Tracks a request by incrementing the total requests counter and associating it with metadata.
+        /// </summary>
+        /// <param name="method">The HTTP method of the request (e.g., GET, POST).</param>
+        /// <param name="statusCode">The HTTP status code of the response.</param>
+        /// <param name="endpoint">The endpoint being accessed.</param>
+        /// <param name="apiType">The type of API being used (e.g., REST, GraphQL).</param>
+        public static void TrackRequest(string method, int statusCode, string endpoint, string apiType)
+        {
+            _totalRequests.Add(1,
+                new("method", method),
+                new("status_code", statusCode),
+                new("endpoint", endpoint),
+                new("api_type", apiType));
+        }
+
+        /// <summary>
+        /// Tracks an error by incrementing the error counter and associating it with metadata.
+        /// </summary>
+        /// <param name="method">The HTTP method of the request (e.g., GET, POST).</param>
+        /// <param name="statusCode">The HTTP status code of the response.</param>
+        /// <param name="endpoint">The endpoint being accessed.</param>
+        /// <param name="apiType">The type of API being used (e.g., REST, GraphQL).</param>
+        /// <param name="ex">The exception that occurred.</param>
+        public static void TrackError(string method, int statusCode, string endpoint, string apiType, Exception ex)
+        {
+            _errorCounter.Add(1,
+                new("method", method),
+                new("status_code", statusCode),
+                new("endpoint", endpoint),
+                new("api_type", apiType),
+                new("error_type", ex.GetType().Name));
+        }
+
+        /// <summary>
+        /// Tracks the duration of a request by recording it in a histogram and associating it with metadata.
+        /// </summary>
+        /// <param name="method">The HTTP method of the request (e.g., GET, POST).</param>
+        /// <param name="statusCode">The HTTP status code of the response.</param>
+        /// <param name="endpoint">The endpoint being accessed.</param>
+        /// <param name="apiType">The type of API being used (e.g., REST, GraphQL).</param>
+        /// <param name="duration">The duration of the request in milliseconds.</param>
+        public static void TrackRequestDuration(string method, int statusCode, string endpoint, string apiType, double duration)
+        {
+            _requestDuration.Record(duration,
+                new("method", method),
+                new("status_code", statusCode),
+                new("endpoint", endpoint),
+                new("api_type", apiType));
+        }
+    }
+}