private static object OnBeginGetResponse <TContext>(object requestObj, Configuration <TContext, WebRequest, WebResponse> config) where TContext : ICorrelationContext <TContext>
{
var request = requestObj as HttpWebRequest;
if (request != null)
{
if (config.EndpointFilter.Validate(request.RequestUri))
{
var ctx = ContextResolver.GetContext <TContext>();
if (ctx != null)
{
foreach (var injector in config.ContextInjectors)
{
injector.UpdateRequest(ctx, request);
}
try
{
config.RequestNotifier?.OnBeforeRequest(ctx.GetChildRequestContext(request.GetChildRequestId()), request);
}
catch (Exception)
{
//ignored
}
}
}
}
return(requestObj);
}
private Task assertEmptyContext(IDictionary <string, object> environment)
{
var ctx = ContextResolver.GetContext <CorrelationContext>();
Assert.NotNull(ctx);
return(Task.FromResult(1));
}
private static void validateHeader(HttpRequestMessage request)
{
IEnumerable <string> actualHeader;
Assert.True(request.Headers.TryGetValues(CorrelationHeaderInfo.CorrelationIdHeaderName, out actualHeader));
Assert.Equal(1, actualHeader.Count());
Assert.Equal(ContextResolver.GetContext <CorrelationContext>().CorrelationId, actualHeader.First());
}
public static void LogIncomingRequest(HttpContext context, TimeSpan elapsed)
{
Log.Write("incoming_request", new
{
context.Request,
context.Response,
Elapsed = elapsed,
Context = ContextResolver.GetContext <CorrelationContext>()
});
}
public void ContextResolverSetClear()
{
var ctx = new TestContext {
CorrelationId = "1", OtherId = "2"
};
ContextResolver.SetContext(ctx);
ContextResolver.ClearContext();
Assert.Null(ContextResolver.GetContext <TestContext>());
}
public void Initialize(ITelemetry telemetry)
{
//add request id to every event
var ctx = ContextResolver.GetContext <CorrelationContext>();
if (ctx != null)
{
telemetry.Context.Operation.Id = ctx.CorrelationId;
telemetry.Context.Operation.ParentId = ctx.RequestId;
}
}
public void PutStringGetObject()
{
var guid = Guid.NewGuid().ToString();
ContextResolver.SetContext(guid);
var got = ContextResolver.GetContext <object>();
Assert.NotNull(got);
Assert.Equal(guid, got.ToString());
}
public void ContextResolverSetGet()
{
var ctx = new TestContext {
CorrelationId = "1", OtherId = "2"
};
ContextResolver.SetContext(ctx);
var gotCtx = ContextResolver.GetContext <TestContext>();
TestContextHelper.AssertAreEqual(ctx, gotCtx);
}
public static void LogOutgoigRequest(HttpResponseMessage response, TimeSpan elapsed)
{
var baseRequestContext = ContextResolver.GetContext <CorrelationContext>();
var childRequestId = response.RequestMessage.GetChildRequestId();
Log.Write("outgoing_request", new
{
Request = response.RequestMessage,
Response = response,
Elapsed = elapsed,
Context = baseRequestContext.GetChildRequestContext(childRequestId)
});
}
public async Task ContextResolverSetGetAsyncTask()
{
var ctx = new TestContext {
CorrelationId = "1", OtherId = "2"
};
ContextResolver.SetContext(ctx);
var t = Task.Run(() => ContextResolver.GetContext <TestContext>());
await t.ConfigureAwait(false);
TestContextHelper.AssertAreEqual(ctx, t.Result);
}
private static void validateRequest(HttpRequestMessage request)
{
var ctx = ContextResolver.GetContext <CorrelationContext>();
IEnumerable <string> correlationIdHeader;
Assert.True(request.Headers.TryGetValues(CorrelationHeaderInfo.CorrelationIdHeaderName, out correlationIdHeader));
Assert.Equal(1, correlationIdHeader.Count());
Assert.Equal(ctx.CorrelationId, correlationIdHeader.First());
IEnumerable <string> requestIdHeader;
Assert.True(request.Headers.TryGetValues(CorrelationHeaderInfo.RequestIdHeaderName, out requestIdHeader));
Assert.Equal(1, requestIdHeader.Count());
Assert.Equal(request.GetChildRequestId(), requestIdHeader.First());
}
protected override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request,
CancellationToken cancellationToken)
{
var ctx = ContextResolver.GetContext <TContext>();
if (ctx != null)
{
foreach (var injector in contextInjectors)
{
injector.UpdateRequest(ctx, request);
}
}
return(base.SendAsync(request, cancellationToken));
}
/// <summary>
/// Gets the property identifier from the @context
/// or as concatenation of class and property name.
/// </summary>
public string GetPropertyId(PropertyInfo property, Uri classId)
{
var context = _contextResolver.GetContext(property.ReflectedType);
if (context != null)
{
var mappedTerm = ContextHelpers.GetExpandedIri(context, property.GetJsonPropertyName());
if (mappedTerm != null)
{
return(mappedTerm);
}
}
return(GetFallbackPropertyId(property, property.GetJsonPropertyName(), classId));
}
public static void LogOutgoingRequest(this ILogger logger, HttpResponseMessage response, TimeSpan elapsed)
{
var baseRequestContext = ContextResolver.GetContext <CorrelationContext>();
var childRequestId = response.RequestMessage.GetChildRequestId();
using (logger.BeginScope(baseRequestContext.GetChildRequestContext(childRequestId)))
{
logger.LogInformation(
new EventId(0, "outgoing_request"),
"outgoing request {method}, {url}, {status} {elapsed}",
response.RequestMessage.Method.ToString(),
response.RequestMessage.RequestUri.AbsoluteUri,
response.StatusCode,
elapsed.TotalMilliseconds);
}
}
public void ContextResolverSetOtherThread()
{
var ctx = new TestContext {
CorrelationId = "1", OtherId = "2"
};
ContextResolver.SetContext(ctx);
TestContext gotCtx = null;
var t = new Thread(() =>
{
gotCtx = ContextResolver.GetContext <TestContext>();
});
t.Start();
t.Join();
TestContextHelper.AssertAreEqual(ctx, gotCtx);
}
/// <summary>
/// Allows to execute a given <paramref name="func" /> within an ensured <paramref name="ctx" /> including
/// disposing the <paramref name="ctx" /> if none was given.
/// </summary>
/// <typeparam name="TResult">The result type of the <paramref name="func" />.</typeparam>
/// <param name="func">The function to execute including an EF context.</param>
/// <param name="ctx">The context or <c>null</c> if a new should be created.</param>
/// <returns>The result of the <paramref name="func" />.</returns>
protected async Task <TResult> ExecuteContextWrappedAsync <TResult>(Func <TContext, Task <TResult> > func, TContext ctx = null)
{
if (func == null)
{
var ex = new ArgumentNullException("func");
Logger.LogException("BU-EX-08", ex);
throw ex;
}
var dispose = false;
if (ctx == null)
{
ctx = ContextResolver.GetContext(typeof(TContext)) as TContext;
if (ctx == null)
{
throw new InvalidOperationException("Can not resolve database context.");
}
dispose = true;
}
var result = default(TResult);
try
{
result = await func(ctx);
}
catch (AggregateException aex)
{
Logger.LogException("BU-EX-001", aex);
if (aex.InnerExceptions.Count > 0)
{
// Loses the proper stack trace. Oops. For workarounds, see
// See http://bradwilson.typepad.com/blog/2008/04/small-decisions.html
Logger.LogException("BU-EX-002", aex.InnerExceptions[0]);
}
}
if (dispose)
{
ctx.Dispose();
}
return(result);
}
public void OnNext(KeyValuePair <string, object> value)
{
if (value.Value == null)
{
return;
}
if (value.Key == "System.Net.Http.Request")
{
var requestInfo = value.Value.GetType().GetProperty("Request");
var request = (HttpRequestMessage)requestInfo?.GetValue(value.Value, null);
if (request != null)
{
var ctx = ContextResolver.GetContext <TContext>();
if (endpointFilter.Validate(request.RequestUri))
{
foreach (var injector in contextInjectors)
{
injector.UpdateRequest(ctx, request);
}
requestNotifier.OnBeforeRequest(ctx, request);
}
}
}
else if (value.Key == "System.Net.Http.Response")
{
var responseInfo = value.Value.GetType().GetProperty("Response");
var response = (HttpResponseMessage)responseInfo?.GetValue(value.Value, null);
if (response != null)
{
if (endpointFilter.Validate(response.RequestMessage.RequestUri))
{
requestNotifier.OnAfterResponse(ContextResolver.GetContext <TContext>(), response);
}
}
}
}
private static object OnEndGetResponse <TContext>(object context, object returnValue, object thisObj, object asyncResult, Configuration <TContext, WebRequest, WebResponse> config) where TContext : ICorrelationContext <TContext>
{
var response = returnValue as WebResponse;
var request = thisObj as WebRequest;
if (request != null && response != null)
{
if (config.EndpointFilter.Validate(request.RequestUri))
{
var ctx = ContextResolver.GetContext <TContext>();
try
{
config.RequestNotifier?.OnAfterResponse(
ctx.GetChildRequestContext(request.GetChildRequestId()), response);
}
catch (Exception)
{
//ignored
}
}
}
return(returnValue);
}
public async Task Invoke(HttpContext context)
{
var ctx = ContextResolver.GetContext <CorrelationContext>();
var relatedActivityId = new Guid(ctx.CorrelationId);
try
{
EventSource.SetCurrentThreadActivityId(relatedActivityId);
MyEventSource.Log.RequestStart(
context.Request.Method,
context.Request.Path.Value,
ctx.CorrelationId,
ctx.RequestId);
await this.next(context).ConfigureAwait(false);
EventSource.SetCurrentThreadActivityId(relatedActivityId);
MyEventSource.Log.RequestStop(context.Response.StatusCode.ToString());
}
catch (Exception ex)
{
EventSource.SetCurrentThreadActivityId(relatedActivityId);
MyEventSource.Log.RequestStop(ex.ToString());
}
}
/// <summary>
/// Allows to execute a given <paramref name="func" /> within an ensured <paramref name="ctx" /> including
/// disposing the <paramref name="ctx" /> if none was given.
/// </summary>
/// <param name="func">The function to execute including an EF context.</param>
/// <param name="ctx">The context or <c>null</c> if a new should be created.</param>
/// <returns>The awaitable task.</returns>
protected async Task ExecuteContextWrappedAsync(Func <TContext, Task> func, TContext ctx = null)
{
if (func == null)
{
var ex = new ArgumentNullException("func");
Logger.LogException("BU-EX-07", ex);
throw ex;
}
var dispose = false;
if (ctx == null)
{
ctx = ContextResolver.GetContext(typeof(TContext)) as TContext;
if (ctx == null)
{
throw new InvalidOperationException("Can not resolve database context.");
}
dispose = true;
}
try
{
await func(ctx);
}
catch (AggregateException aex)
{
Logger.LogException("BU-EX-003", aex);
if (aex.InnerExceptions.Count > 0)
{
Logger.LogException("BU-EX-004", aex.InnerExceptions[0]);
}
}
if (dispose)
{
ctx.Dispose();
}
}
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter)
{
var document = new Dictionary <string, object>
{
["Message"] = formatter(state, exception),
["LogLevel"] = logLevel,
["Exception"] = exception,
["EventId"] = eventId,
["Timestamp"] = DateTime.UtcNow,
["CategoryName"] = categoryName
};
if (scope?.State != null)
{
document["Context"] = scope?.State;
}
else
{
var ctx = ContextResolver.GetContext <CorrelationContext>();
if (ctx != null)
{
document["Context"] = ctx;
}
}
var formattedState = state as FormattedLogValues;
if (formattedState != null)
{
for (int i = 0; i < formattedState.Count - 1; i++)
{
document.Add(formattedState[i].Key, formattedState[i].Value);
}
}
client.Index(document, idx => idx.Index(IndexName));
}
public void ContextResolverEmpty()
{
Assert.Null(ContextResolver.GetContext <TestContext>());
}