starred/WireMock.Net-wiremock
1
0
Fork 0
mirror of https://github.com/wiremock/WireMock.Net.git synced 2026-04-25 01:38:27 +02:00
Code Issues 32 Packages Projects Releases 10 Wiki Activity

Add OTEL tracing support for Wiremock + automatic OTEL for Aspire integration (#1418)

Browse Source 
* Update aspire to 13.1 (examples + code)

Allows usage of aspire CLI which is very useful for dev in codespaces (for my next PR).

* Add OTEL support

* Initial PR feedback

* PR feedback

* PR feedback

* PR feedback

* Cleanup.

* Cleanup

* Fix

* Fix

* Rename stuff around to be more accurate

* PR feedback

* Update WireMock.Net.OpenTelemetry.csproj

Update <Authors>

* PR feedback parser

* PR feedback package versions

* Status code feedback.

* Update preprocessor directives to to Activity Tracing instead of OpenTelemetry. Is more descriptive.

* Add tests

* Improve tests

---------

Co-authored-by: Stef Heyenrath <Stef.Heyenrath@gmail.com>
This commit is contained in:
Petr Houška
2026-01-18 17:22:36 +01:00
committed by GitHub
parent abe996671e
commit 4525c61847
38 changed files with 2057 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
src/WireMock.Net.Minimal/Owin/ActivityTracing/ActivityTracingOptions.cs Normal file
View File

@@ -0,0 +1,38 @@
// Copyright © WireMock.Net
#if ACTIVITY_TRACING_SUPPORTED
namespace WireMock.Owin.ActivityTracing;
/// <summary>
/// Options for controlling activity tracing in WireMock.Net middleware.
/// These options control the creation of System.Diagnostics.Activity objects
/// but do not require any OpenTelemetry exporter dependencies.
/// </summary>
public class ActivityTracingOptions
{
/// <summary>
/// Gets or sets a value indicating whether to exclude admin interface requests from tracing.
/// Default is <c>true</c>.
/// </summary>
public bool ExcludeAdminRequests { get; set; } = true;
/// <summary>
/// Gets or sets a value indicating whether to record request body in trace attributes.
/// Default is <c>false</c> due to potential PII concerns.
/// </summary>
public bool RecordRequestBody { get; set; }
/// <summary>
/// Gets or sets a value indicating whether to record response body in trace attributes.
/// Default is <c>false</c> due to potential PII concerns.
/// </summary>
public bool RecordResponseBody { get; set; }
/// <summary>
/// Gets or sets a value indicating whether to record mapping match details in trace attributes.
/// Default is <c>true</c>.
/// </summary>
public bool RecordMatchDetails { get; set; } = true;
}
#endif

34
src/WireMock.Net.Minimal/Owin/ActivityTracing/ActivityTracingValidator.cs Normal file
View File

@@ -0,0 +1,34 @@
// Copyright © WireMock.Net
#if !ACTIVITY_TRACING_SUPPORTED
using System;
#endif
using WireMock.Settings;
namespace WireMock.Owin.ActivityTracing;
/// <summary>
/// Validator for Activity Tracing configuration.
/// </summary>
internal static class ActivityTracingValidator
{
/// <summary>
/// Validates that Activity Tracing is supported on the current framework.
/// Throws an exception if ActivityTracingOptions is configured on an unsupported framework.
/// </summary>
/// <param name="settings">The WireMock server settings to validate.</param>
/// <exception cref="System.InvalidOperationException">
/// Thrown when ActivityTracingOptions is configured but the current framework does not support System.Diagnostics.Activity.
/// </exception>
public static void ValidateActivityApiPresence(WireMockServerSettings settings)
{
#if !ACTIVITY_TRACING_SUPPORTED
if (settings.ActivityTracingOptions is not null)
{
throw new InvalidOperationException(
"Activity Tracing is not supported on this target framework. " +
"It requires .NET 5.0 or higher which includes System.Diagnostics.Activity support.");
}
#endif
}
}

201
src/WireMock.Net.Minimal/Owin/ActivityTracing/WireMockActivitySource.cs Normal file
View File

@@ -0,0 +1,201 @@
// Copyright © WireMock.Net
#if ACTIVITY_TRACING_SUPPORTED
using System;
using System.Collections.Generic;
using System.Diagnostics;
using WireMock.Logging;
namespace WireMock.Owin.ActivityTracing;
/// <summary>
/// Provides an ActivitySource for WireMock.Net distributed tracing.
/// </summary>
public static class WireMockActivitySource
{
/// <summary>
/// The name of the ActivitySource used by WireMock.Net.
/// </summary>
internal const string SourceName = "WireMock.Net";
/// <summary>
/// The ActivitySource instance used for creating tracing activities.
/// </summary>
public static readonly ActivitySource Source = new(SourceName, GetVersion());
private static string GetVersion()
{
return typeof(WireMockActivitySource).Assembly.GetName().Version?.ToString() ?? "1.0.0";
}
/// <summary>
/// Starts a new activity for a WireMock request.
/// </summary>
/// <param name="requestMethod">The HTTP method of the request.</param>
/// <param name="requestPath">The path of the request.</param>
/// <returns>The started activity, or null if tracing is not enabled.</returns>
internal static Activity? StartRequestActivity(string requestMethod, string requestPath)
{
if (!Source.HasListeners())
{
return null;
}
var activity = Source.StartActivity(
$"WireMock {requestMethod} {requestPath}",
ActivityKind.Server
);
return activity;
}
/// <summary>
/// Enriches an activity with request information.
/// </summary>
internal static void EnrichWithRequest(Activity? activity, IRequestMessage request, ActivityTracingOptions? options = null)
{
if (activity == null)
{
return;
}
activity.SetTag(WireMockSemanticConventions.HttpMethod, request.Method);
activity.SetTag(WireMockSemanticConventions.HttpUrl, request.Url);
activity.SetTag(WireMockSemanticConventions.HttpPath, request.Path);
activity.SetTag(WireMockSemanticConventions.HttpHost, request.Host);
if (request.ClientIP != null)
{
activity.SetTag(WireMockSemanticConventions.ClientAddress, request.ClientIP);
}
// Record request body if enabled
if (options?.RecordRequestBody == true && request.Body != null)
{
activity.SetTag(WireMockSemanticConventions.RequestBody, request.Body);
}
}
/// <summary>
/// Enriches an activity with response information.
/// </summary>
internal static void EnrichWithResponse(Activity? activity, IResponseMessage? response, ActivityTracingOptions? options = null)
{
if (activity == null || response == null)
{
return;
}
// StatusCode can be int, HttpStatusCode, or string
var statusCode = response.StatusCode;
int? statusCodeInt = statusCode switch
{
int i => i,
System.Net.HttpStatusCode hsc => (int)hsc,
string s when int.TryParse(s, out var parsed) => parsed,
_ => null
};
if (statusCodeInt.HasValue)
{
activity.SetTag(WireMockSemanticConventions.HttpStatusCode, statusCodeInt.Value);
activity.SetTag("otel.status_description", $"HTTP {statusCodeInt.Value}");
// Set status based on HTTP status code (using standard otel.status_code tag)
if (statusCodeInt.Value >= 400)
{
activity.SetTag("otel.status_code", "ERROR");
}
else
{
activity.SetTag("otel.status_code", "OK");
}
}
// Record response body if enabled
if (options?.RecordResponseBody == true && response.BodyData?.BodyAsString != null)
{
activity.SetTag(WireMockSemanticConventions.ResponseBody, response.BodyData.BodyAsString);
}
}
/// <summary>
/// Enriches an activity with mapping match information.
/// </summary>
internal static void EnrichWithMappingMatch(
Activity? activity,
Guid? mappingGuid,
string? mappingTitle,
bool isPerfectMatch,
double? matchScore)
{
if (activity == null)
{
return;
}
activity.SetTag(WireMockSemanticConventions.MappingMatched, isPerfectMatch);
if (mappingGuid.HasValue)
{
activity.SetTag(WireMockSemanticConventions.MappingGuid, mappingGuid.Value.ToString());
}
if (!string.IsNullOrEmpty(mappingTitle))
{
activity.SetTag(WireMockSemanticConventions.MappingTitle, mappingTitle);
}
if (matchScore.HasValue)
{
activity.SetTag(WireMockSemanticConventions.MatchScore, matchScore.Value);
}
}
/// <summary>
/// Enriches an activity with log entry information (includes response and mapping match info).
/// </summary>
internal static void EnrichWithLogEntry(Activity? activity, ILogEntry logEntry, ActivityTracingOptions? options = null)
{
if (activity == null)
{
return;
}
// Enrich with response
EnrichWithResponse(activity, logEntry.ResponseMessage, options);
// Enrich with mapping match (if enabled)
if (options?.RecordMatchDetails != false)
{
EnrichWithMappingMatch(
activity,
logEntry.MappingGuid,
logEntry.MappingTitle,
logEntry.RequestMatchResult?.IsPerfectMatch ?? false,
logEntry.RequestMatchResult?.TotalScore);
}
// Set request GUID
activity.SetTag(WireMockSemanticConventions.RequestGuid, logEntry.Guid.ToString());
}
/// <summary>
/// Records an exception on the activity.
/// </summary>
internal static void RecordException(Activity? activity, Exception exception)
{
if (activity == null)
{
return;
}
// Use standard OpenTelemetry exception semantic conventions
activity.SetTag("otel.status_code", "ERROR");
activity.SetTag("otel.status_description", exception.Message);
activity.SetTag("exception.type", exception.GetType().FullName);
activity.SetTag("exception.message", exception.Message);
activity.SetTag("exception.stacktrace", exception.ToString());
}
}
#endif

34
src/WireMock.Net.Minimal/Owin/ActivityTracing/WireMockSemanticConventions.cs Normal file
View File

@@ -0,0 +1,34 @@
// Copyright © WireMock.Net
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace WireMock.Owin.ActivityTracing;
/// <summary>
/// Semantic convention constants for WireMock.Net tracing attributes.
/// </summary>
internal static class WireMockSemanticConventions
{
// Standard HTTP semantic conventions (OpenTelemetry)
public const string HttpMethod = "http.request.method";
public const string HttpUrl = "url.full";
public const string HttpPath = "url.path";
public const string HttpHost = "server.address";
public const string HttpStatusCode = "http.response.status_code";
public const string ClientAddress = "client.address";
// WireMock-specific attributes
public const string MappingMatched = "wiremock.mapping.matched";
public const string MappingGuid = "wiremock.mapping.guid";
public const string MappingTitle = "wiremock.mapping.title";
public const string MatchScore = "wiremock.match.score";
public const string PartialMappingGuid = "wiremock.partial_mapping.guid";
public const string PartialMappingTitle = "wiremock.partial_mapping.title";
public const string RequestGuid = "wiremock.request.guid";
public const string RequestBody = "wiremock.request.body";
public const string ResponseBody = "wiremock.response.body";
}

9
src/WireMock.Net.Minimal/Owin/IWireMockMiddlewareOptions.cs
View File

@@ -5,6 +5,7 @@ using System.Collections.Concurrent;
using WireMock.Handlers;
using WireMock.Logging;
using WireMock.Matchers;
using WireMock.Owin.ActivityTracing;
using WireMock.Types;
using WireMock.Util;
using System.Security.Cryptography.X509Certificates;
@@ -90,4 +91,12 @@ internal interface IWireMockMiddlewareOptions
QueryParameterMultipleValueSupport? QueryParameterMultipleValueSupport { get; set; }
public bool ProxyAll { get; set; }
#if ACTIVITY_TRACING_SUPPORTED
/// <summary>
/// Gets or sets the activity tracing options.
/// When set, System.Diagnostics.Activity objects are created for request tracing.
/// </summary>
ActivityTracingOptions? ActivityTracingOptions { get; set; }
#endif
}

47
src/WireMock.Net.Minimal/Owin/WireMockMiddleware.cs
View File

@@ -16,6 +16,10 @@ using System.Collections.Generic;
using WireMock.Constants;
using WireMock.Exceptions;
using WireMock.Util;
#if ACTIVITY_TRACING_SUPPORTED
using System.Diagnostics;
using WireMock.Owin.ActivityTracing;
#endif
#if !USE_ASPNETCORE
using IContext = Microsoft.Owin.IOwinContext;
using OwinMiddleware = Microsoft.Owin.OwinMiddleware;
@@ -97,6 +101,40 @@ namespace WireMock.Owin
{
var request = await _requestMapper.MapAsync(ctx.Request, _options).ConfigureAwait(false);
#if ACTIVITY_TRACING_SUPPORTED
// Start activity if ActivityTracingOptions is configured
var tracingEnabled = _options.ActivityTracingOptions is not null;
var excludeAdmin = _options.ActivityTracingOptions?.ExcludeAdminRequests ?? true;
Activity? activity = null;
// Check if we should trace this request (optionally exclude admin requests)
var shouldTrace = tracingEnabled && !(excludeAdmin && request.Path.StartsWith("/__admin/"));
if (shouldTrace)
{
activity = WireMockActivitySource.StartRequestActivity(request.Method, request.Path);
WireMockActivitySource.EnrichWithRequest(activity, request, _options.ActivityTracingOptions);
}
try
{
await InvokeInternalCoreAsync(ctx, request, activity).ConfigureAwait(false);
}
finally
{
activity?.Dispose();
}
#else
await InvokeInternalCoreAsync(ctx, request).ConfigureAwait(false);
#endif
}
#if ACTIVITY_TRACING_SUPPORTED
private async Task InvokeInternalCoreAsync(IContext ctx, RequestMessage request, Activity? activity)
#else
private async Task InvokeInternalCoreAsync(IContext ctx, RequestMessage request)
#endif
{
var logRequest = false;
IResponseMessage? response = null;
(MappingMatcherResult? Match, MappingMatcherResult? Partial) result = (null, null);
@@ -193,6 +231,10 @@ namespace WireMock.Owin
{
_options.Logger.Error($"Providing a Response for Mapping '{result.Match?.Mapping.Guid}' failed. HttpStatusCode set to 500. Exception: {ex}");
response = ResponseMessageBuilder.Create(500, ex.Message);
#if ACTIVITY_TRACING_SUPPORTED
WireMockActivitySource.RecordException(activity, ex);
#endif
}
finally
{
@@ -211,6 +253,11 @@ namespace WireMock.Owin
PartialMatchResult = result.Partial?.RequestMatchResult
};
#if ACTIVITY_TRACING_SUPPORTED
// Enrich activity with response and mapping info
WireMockActivitySource.EnrichWithLogEntry(activity, log, _options.ActivityTracingOptions);
#endif
LogRequest(log, logRequest);
try

6
src/WireMock.Net.Minimal/Owin/WireMockMiddlewareOptions.cs
View File

@@ -5,6 +5,7 @@ using System.Collections.Concurrent;
using WireMock.Handlers;
using WireMock.Logging;
using WireMock.Matchers;
using WireMock.Owin.ActivityTracing;
using WireMock.Types;
using WireMock.Util;
using System.Security.Cryptography.X509Certificates;
@@ -106,4 +107,9 @@ internal class WireMockMiddlewareOptions : IWireMockMiddlewareOptions
/// <inheritdoc />
public bool ProxyAll { get; set; }
#if ACTIVITY_TRACING_SUPPORTED
/// <inheritdoc />
public ActivityTracingOptions? ActivityTracingOptions { get; set; }
#endif
}

22
src/WireMock.Net.Minimal/Owin/WireMockMiddlewareOptionsHelper.cs
View File

@@ -2,6 +2,7 @@
using System;
using Stef.Validation;
using WireMock.Owin.ActivityTracing;
using WireMock.Settings;
namespace WireMock.Owin;
@@ -34,6 +35,27 @@ internal static class WireMockMiddlewareOptionsHelper
options.RequestLogExpirationDuration = settings.RequestLogExpirationDuration;
options.SaveUnmatchedRequests = settings.SaveUnmatchedRequests;
// Validate and configure activity tracing
ActivityTracingValidator.ValidateActivityApiPresence(settings);
#if ACTIVITY_TRACING_SUPPORTED
if (settings.ActivityTracingOptions is not null)
{
options.ActivityTracingOptions = new Owin.ActivityTracing.ActivityTracingOptions
{
ExcludeAdminRequests = settings.ActivityTracingOptions.ExcludeAdminRequests,
RecordRequestBody = settings.ActivityTracingOptions.RecordRequestBody,
RecordResponseBody = settings.ActivityTracingOptions.RecordResponseBody,
RecordMatchDetails = settings.ActivityTracingOptions.RecordMatchDetails
};
}
#endif
#if USE_ASPNETCORE
options.AdditionalServiceRegistration = settings.AdditionalServiceRegistration;
options.CorsPolicyOptions = settings.CorsPolicyOptions;
options.ClientCertificateMode = settings.ClientCertificateMode;
options.AcceptAnyClientCertificate = settings.AcceptAnyClientCertificate;
#endif
if (settings.CustomCertificateDefined)
{
options.X509StoreName = settings.CertificateSettings!.X509StoreName;