public void Lookup_SystemData_Succeeds()
{
var expectedModule = typeof(System.Data.DataTable).Assembly.ManifestModule;
var lookup = ModuleLookup.Get(expectedModule.ModuleVersionId);
Assert.Equal(expectedModule, lookup);
}
public void Lookup_DatadogTrace_Succeeds()
{
var expectedModule = typeof(Span).Assembly.ManifestModule;
var lookup = ModuleLookup.Get(expectedModule.ModuleVersionId);
Assert.Equal(expectedModule, lookup);
}
public void Lookup_DatadogTraceClrProfilerManaged_Succeeds()
{
var expectedModule = typeof(MethodBuilder <>).Assembly.ManifestModule;
var lookup = ModuleLookup.Get(expectedModule.ModuleVersionId);
Assert.Equal(expectedModule, lookup);
}
public void Lookup_Self_Succeeds()
{
var expectedModule = typeof(ModuleLookupTests).Assembly.ManifestModule;
var lookup = ModuleLookup.Get(expectedModule.ModuleVersionId);
Assert.Equal(expectedModule, lookup);
}
private static void Rethrow(object context, int opCode, int mdToken, long moduleVersionPtr, string contextType)
{
Action <object> instrumentedMethod;
try
{
var module = ModuleLookup.GetByPointer(moduleVersionPtr);
var concreteType = module.GetType(contextType);
instrumentedMethod =
MethodBuilder <Action <object> >
.Start(moduleVersionPtr, mdToken, opCode, nameof(Rethrow))
.WithConcreteType(concreteType)
.WithParameters(context)
.WithNamespaceAndNameFilters(ClrNames.Void, contextType)
.Build();
}
catch (Exception ex)
{
Log.ErrorRetrievingMethod(
exception: ex,
moduleVersionPointer: moduleVersionPtr,
mdToken: mdToken,
opCode: opCode,
instrumentedType: ResourceInvokerTypeName,
methodName: nameof(Rethrow),
instanceType: null,
relevantArguments: new[] { context.GetType().AssemblyQualifiedName });
throw;
}
AspNetCoreMvcContext integration = null;
try
{
if (context.TryGetPropertyValue("HttpContext", out object httpContext))
{
if (httpContext.TryGetPropertyValue("Items", out IDictionary <object, object> contextItems))
{
integration = contextItems?[HttpContextKey] as AspNetCoreMvcContext;
}
}
}
catch (Exception ex)
{
Log.Error(ex, $"Error accessing {nameof(AspNetCoreMvc3Integration)}.");
}
try
{
// call the original method, observing any unhandled exceptions
instrumentedMethod.Invoke(context);
}
catch (Exception ex)
{
integration?.Scope?.Span?.SetException(ex);
throw;
}
}
public static void InvokePreStartInitMethods(
object methodInfoCollection,
int opCode,
int mdToken,
long moduleVersionPtr)
{
// The whole point of instrumenting a method so early on in the application load process
// is to register our HttpModule.
HttpApplication.RegisterModule(typeof(TracingHttpModule));
Action <object> instrumentedMethod;
Type concreteType = null;
try
{
var module = ModuleLookup.GetByPointer(moduleVersionPtr);
concreteType = module.GetType(BuildManagerTypeName);
}
catch (Exception ex)
{
Log.ErrorRetrievingMethod(
exception: ex,
moduleVersionPointer: moduleVersionPtr,
mdToken: mdToken,
opCode: opCode,
instrumentedType: BuildManagerTypeName,
methodName: nameof(InvokePreStartInitMethods),
instanceType: null,
relevantArguments: new[] { concreteType?.AssemblyQualifiedName });
throw;
}
try
{
instrumentedMethod =
MethodBuilder <Action <object> >
.Start(moduleVersionPtr, mdToken, opCode, nameof(InvokePreStartInitMethods))
.WithParameters(methodInfoCollection)
.WithConcreteType(concreteType)
.Build();
}
catch (Exception ex)
{
Log.ErrorRetrievingMethod(
exception: ex,
moduleVersionPointer: moduleVersionPtr,
mdToken: mdToken,
opCode: opCode,
null,
methodName: nameof(InvokePreStartInitMethods));
throw;
}
instrumentedMethod(methodInfoCollection);
}
public void Lookup_SystemData_Succeeds_WithTwentyConcurrentTries()
{
var tasks = new Task[20];
var resetEvent = new ManualResetEventSlim(initialState: false);
var bag = new ConcurrentBag <Module>();
var systemDataGuid = typeof(System.Data.DataTable).Assembly.ManifestModule.ModuleVersionId;
for (var i = 0; i < 20; i++)
{
tasks[i] = Task.Run(() =>
{
resetEvent.Wait();
bag.Add(ModuleLookup.Get(systemDataGuid));
});
}
resetEvent.Set();
Task.WaitAll(tasks);
Assert.True(bag.All(m => m.ModuleVersionId == systemDataGuid) && bag.Count() == tasks.Length);
}
public static void AfterAction(
object diagnosticListener,
object controllerActionDescriptor,
object httpContext,
object routeData,
int opCode,
int mdToken,
long moduleVersionPtr)
{
AspNetCoreMvcContext context = null;
try
{
if (httpContext.TryGetPropertyValue("Items", out IDictionary <object, object> contextItems))
{
context = contextItems?[HttpContextKey] as AspNetCoreMvcContext;
}
}
catch (Exception ex)
{
Log.Error(ex, $"Error accessing {nameof(AspNetCoreMvcContext)}.");
}
Action <object, object, object, object> instrumentedMethod = null;
Type concreteType = null;
try
{
var module = ModuleLookup.GetByPointer(moduleVersionPtr);
concreteType = module.GetType(DiagnosticListenerExtensionsTypeName);
instrumentedMethod =
MethodBuilder <Action <object, object, object, object> >
.Start(module, mdToken, opCode, nameof(AfterAction))
.WithConcreteType(concreteType)
.WithParameters(diagnosticListener, controllerActionDescriptor, httpContext, routeData)
.WithNamespaceAndNameFilters(
ClrNames.Void,
DiagnosticListenerTypeName,
ControllerActionDescriptorTypeName,
ClrNames.Ignore,
RouteDataTypeName)
.Build();
}
catch (Exception ex)
{
Log.ErrorRetrievingMethod(
exception: ex,
moduleVersionPointer: moduleVersionPtr,
mdToken: mdToken,
opCode: opCode,
instrumentedType: DiagnosticListenerExtensionsTypeName,
methodName: nameof(AfterAction),
instanceType: null,
relevantArguments: new[] { concreteType?.AssemblyQualifiedName });
throw;
}
try
{
// call the original method, catching and rethrowing any unhandled exceptions
instrumentedMethod.Invoke(diagnosticListener, controllerActionDescriptor, httpContext, routeData);
}
catch (Exception ex)
{
context?.Scope?.Span?.SetException(ex);
throw;
}
finally
{
context?.Scope?.Dispose();
}
}