Refactor

Author: reakaleek

src/api/Elastic.Documentation.Api.Core/Elastic.Documentation.Api.Core.csproj

@@ -12,6 +12,7 @@
       <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" />
       <PackageReference Include="Microsoft.Extensions.Logging" />
       <PackageReference Include="Microsoft.Extensions.Telemetry.Abstractions" />
+      <PackageReference Include="NetEscapades.EnumGenerators" />
     </ItemGroup>
 
 </Project>

src/api/Elastic.Documentation.Api.Core/Telemetry/IOtlpGateway.cs

@@ -12,13 +12,13 @@ public interface IOtlpGateway
 	/// <summary>
 	/// Forwards OTLP telemetry data to the collector.
 	/// </summary>
-	/// <param name="signalType">The OTLP signal type: traces, logs, or metrics</param>
+	/// <param name="signalType">The OTLP signal type (traces, logs, or metrics)</param>
 	/// <param name="requestBody">The raw OTLP payload stream</param>
 	/// <param name="contentType">Content-Type of the payload</param>
 	/// <param name="ctx">Cancellation token</param>
 	/// <returns>HTTP status code and response content</returns>
 	Task<(int StatusCode, string? Content)> ForwardOtlp(
-		string signalType,
+		OtlpSignalType signalType,
 		Stream requestBody,
 		string contentType,
 		Cancel ctx = default);

src/api/Elastic.Documentation.Api.Core/Telemetry/OtlpProxyRequest.cs

@@ -2,8 +2,37 @@
 // Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information
 
+using System.ComponentModel.DataAnnotations;
+using NetEscapades.EnumGenerators;
+
 namespace Elastic.Documentation.Api.Core.Telemetry;
 
+/// <summary>
+/// OTLP signal types supported by the proxy.
+/// The Display names match the OTLP path segments (lowercase).
+/// </summary>
+[EnumExtensions]
+public enum OtlpSignalType
+{
+	/// <summary>
+	/// Distributed traces - maps to /v1/traces
+	/// </summary>
+	[Display(Name = "traces")]
+	Traces,
+
+	/// <summary>
+	/// Log records - maps to /v1/logs
+	/// </summary>
+	[Display(Name = "logs")]
+	Logs,
+
+	/// <summary>
+	/// Metrics data - maps to /v1/metrics
+	/// </summary>
+	[Display(Name = "metrics")]
+	Metrics
+}
+
 /// <summary>
 /// Request model for OTLP proxy endpoint.
 /// Accepts raw OTLP payload from frontend and forwards to configured OTLP endpoint.
@@ -15,4 +44,3 @@ public class OtlpProxyRequest
 	/// </summary>
 	public required string SignalType { get; init; }
 }
-

src/api/Elastic.Documentation.Api.Core/Telemetry/OtlpProxyUsecase.cs

@@ -3,43 +3,33 @@
 // See the LICENSE file in the project root for more information
 
 using System.Diagnostics;
-using Microsoft.Extensions.Logging;
 
 namespace Elastic.Documentation.Api.Core.Telemetry;
 
 /// <summary>
 /// Proxies OTLP telemetry from the frontend to the local ADOT Lambda Layer collector.
 /// The ADOT layer handles authentication and forwarding to the backend.
 /// </summary>
-public class OtlpProxyUsecase(
-	IOtlpGateway gateway,
-	ILogger<OtlpProxyUsecase> logger)
+public class OtlpProxyUsecase(IOtlpGateway gateway)
 {
 	private static readonly ActivitySource ActivitySource = new(TelemetryConstants.OtlpProxySourceName);
 
 	/// <summary>
 	/// Proxies OTLP data from the frontend to the local ADOT collector.
 	/// </summary>
-	/// <param name="signalType">The OTLP signal type: traces, logs, or metrics</param>
+	/// <param name="signalType">The OTLP signal type (traces, logs, or metrics)</param>
 	/// <param name="requestBody">The raw OTLP payload (JSON or protobuf)</param>
 	/// <param name="contentType">Content-Type header from the original request</param>
 	/// <param name="ctx">Cancellation token</param>
 	/// <returns>HTTP status code and response content</returns>
 	public async Task<(int StatusCode, string? Content)> ProxyOtlp(
-		string signalType,
+		OtlpSignalType signalType,
 		Stream requestBody,
 		string contentType,
 		Cancel ctx = default)
 	{
 		using var activity = ActivitySource.StartActivity("ProxyOtlp", ActivityKind.Client);
 
-		// Validate signal type
-		if (signalType is not ("traces" or "logs" or "metrics"))
-		{
-			logger.LogWarning("Invalid OTLP signal type: {SignalType}", signalType);
-			return (400, $"Invalid signal type: {signalType}. Must be traces, logs, or metrics");
-		}
-
 		// Forward to gateway
 		return await gateway.ForwardOtlp(signalType, requestBody, contentType, ctx);
 	}

src/api/Elastic.Documentation.Api.Infrastructure/Adapters/Telemetry/AdotOtlpGateway.cs

@@ -11,39 +11,39 @@ namespace Elastic.Documentation.Api.Infrastructure.Adapters.Telemetry;
 /// Gateway that forwards OTLP telemetry to the ADOT Lambda Layer collector.
 /// </summary>
 public class AdotOtlpGateway(
+	IHttpClientFactory httpClientFactory,
 	OtlpProxyOptions options,
 	ILogger<AdotOtlpGateway> logger) : IOtlpGateway
 {
-	private static readonly HttpClient HttpClient = new()
-	{
-		Timeout = TimeSpan.FromSeconds(30)
-	};
+	public const string HttpClientName = "OtlpProxy";
+	private readonly HttpClient _httpClient = httpClientFactory.CreateClient(HttpClientName);
 
 	/// <inheritdoc />
 	public async Task<(int StatusCode, string? Content)> ForwardOtlp(
-		string signalType,
+		OtlpSignalType signalType,
 		Stream requestBody,
 		string contentType,
 		Cancel ctx = default)
 	{
 		try
 		{
 			// Build the target URL: http://localhost:4318/v1/{signalType}
-			var targetUrl = $"{options.Endpoint.TrimEnd('/')}/v1/{signalType}";
+			// Use ToStringFast(true) from generated enum extensions (returns Display name: "traces", "logs", "metrics")
+			var targetUrl = $"{options.Endpoint.TrimEnd('/')}/v1/{signalType.ToStringFast(true)}";
 
 			logger.LogDebug("Forwarding OTLP {SignalType} to ADOT collector at {TargetUrl}", signalType, targetUrl);
 
 			using var request = new HttpRequestMessage(HttpMethod.Post, targetUrl);
 
-			// Forward the content
+			// Forward the content with the original content type
 			request.Content = new StreamContent(requestBody);
-			request.Content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue(contentType);
+			_ = request.Content.Headers.TryAddWithoutValidation("Content-Type", contentType);
 
 			// No need to add authentication headers - ADOT layer handles auth to backend
 			// Just forward the telemetry to the local collector
 
 			// Forward to ADOT collector
-			using var response = await HttpClient.SendAsync(request, HttpCompletionOption.ResponseContentRead, ctx);
+			using var response = await _httpClient.SendAsync(request, HttpCompletionOption.ResponseContentRead, ctx);
 			var responseContent = response.Content.Headers.ContentLength > 0
 				? await response.Content.ReadAsStringAsync(ctx)
 				: string.Empty;

src/api/Elastic.Documentation.Api.Infrastructure/MappingsExtensions.cs

@@ -69,7 +69,7 @@ private static void MapOtlpProxyEndpoint(IEndpointRouteBuilder group)
 			async (HttpContext context, OtlpProxyUsecase proxyUsecase, Cancel ctx) =>
 			{
 				var contentType = context.Request.ContentType ?? "application/json";
-				var (statusCode, content) = await proxyUsecase.ProxyOtlp("traces", context.Request.Body, contentType, ctx);
+				var (statusCode, content) = await proxyUsecase.ProxyOtlp(OtlpSignalType.Traces, context.Request.Body, contentType, ctx);
 				return Results.Content(content ?? string.Empty, contentType, statusCode: statusCode);
 			})
 			.DisableAntiforgery(); // Frontend requests won't have antiforgery tokens
@@ -80,7 +80,7 @@ private static void MapOtlpProxyEndpoint(IEndpointRouteBuilder group)
 			async (HttpContext context, OtlpProxyUsecase proxyUsecase, Cancel ctx) =>
 			{
 				var contentType = context.Request.ContentType ?? "application/json";
-				var (statusCode, content) = await proxyUsecase.ProxyOtlp("logs", context.Request.Body, contentType, ctx);
+				var (statusCode, content) = await proxyUsecase.ProxyOtlp(OtlpSignalType.Logs, context.Request.Body, contentType, ctx);
 				return Results.Content(content ?? string.Empty, contentType, statusCode: statusCode);
 			})
 			.DisableAntiforgery();
@@ -91,7 +91,7 @@ private static void MapOtlpProxyEndpoint(IEndpointRouteBuilder group)
 			async (HttpContext context, OtlpProxyUsecase proxyUsecase, Cancel ctx) =>
 			{
 				var contentType = context.Request.ContentType ?? "application/json";
-				var (statusCode, content) = await proxyUsecase.ProxyOtlp("metrics", context.Request.Body, contentType, ctx);
+				var (statusCode, content) = await proxyUsecase.ProxyOtlp(OtlpSignalType.Metrics, context.Request.Body, contentType, ctx);
 				return Results.Content(content ?? string.Empty, contentType, statusCode: statusCode);
 			})
 			.DisableAntiforgery();

src/api/Elastic.Documentation.Api.Infrastructure/ServicesExtension.cs

@@ -186,6 +186,14 @@ private static void AddOtlpProxyUsecase(IServiceCollection services, AppEnv appE
 			var config = sp.GetRequiredService<IConfiguration>();
 			return new OtlpProxyOptions(config);
 		});
+
+		// Register named HttpClient for OTLP proxy
+		_ = services.AddHttpClient(AdotOtlpGateway.HttpClientName)
+			.ConfigureHttpClient(client =>
+			{
+				client.Timeout = TimeSpan.FromSeconds(30);
+			});
+
 		_ = services.AddScoped<IOtlpGateway, AdotOtlpGateway>();
 		_ = services.AddScoped<OtlpProxyUsecase>();
 		logger?.LogInformation("OTLP proxy configured to forward to ADOT Lambda Layer collector");

tests-integration/Elastic.Documentation.Api.IntegrationTests/Examples/ServiceMockingExampleTests.cs

@@ -27,7 +27,7 @@ public async Task ExampleWithMultipleServiceMocks()
 
 		// Configure mock behaviors
 		A.CallTo(() => mockOtlpGateway.ForwardOtlp(
-			A<string>._,
+			A<OtlpSignalType>._,
 			A<Stream>._,
 			A<string>._,
 			A<Cancel>._))
@@ -80,7 +80,7 @@ public async Task ExampleWithSingletonMock()
 	{
 		// Arrange
 		var mockGateway = A.Fake<IOtlpGateway>();
-		A.CallTo(() => mockGateway.ForwardOtlp(A<string>._, A<Stream>._, A<string>._, A<Cancel>._))
+		A.CallTo(() => mockGateway.ForwardOtlp(A<OtlpSignalType>._, A<Stream>._, A<string>._, A<Cancel>._))
 			.Returns(Task.FromResult<(int, string?)>((503, "Unavailable")));
 
 		// Use ReplaceSingleton for services registered as singletons

tests-integration/Elastic.Documentation.Api.IntegrationTests/Fixtures/ApiWebApplicationFactory.cs

@@ -51,6 +51,14 @@ public static ApiWebApplicationFactory WithMockedServices(Action<ServiceReplacem
 		return new ApiWebApplicationFactory(builder.Build());
 	}
 
+	/// <summary>
+	/// Creates a factory with custom service configuration.
+	/// </summary>
+	/// <param name="configureServices">Action to configure services directly</param>
+	/// <returns>New factory instance with custom service configuration</returns>
+	public static ApiWebApplicationFactory WithMockedServices(Action<IServiceCollection> configureServices)
+		=> new(configureServices);
+
 	protected override void ConfigureWebHost(IWebHostBuilder builder) => builder.ConfigureServices(services =>
 																			  {
 																				  var otelBuilder = services.AddOpenTelemetry();