public WrapperMap(IEnumerable <IWrapper> wrappers, IDefaultWrapper defaultWrapper, INoOpWrapper noOpWrapper)
{
_nonDefaultWrappers = wrappers
.Where(wrapper => wrapper != null)
.Where(wrapper => !(wrapper is IDefaultWrapper) && !(wrapper is INoOpWrapper))
.ToList();
_nonDefaultWrappers.Add(new AttachToAsyncWrapper());
_nonDefaultWrappers.Add(new DetachWrapper());
_nonDefaultWrappers.Add(new CustomSegmentWrapper());
_nonDefaultWrappers.Add(new IgnoreTransactionWrapper());
_nonDefaultWrappers.Add(new MultithreadedTrackingWrapper());
_nonDefaultWrappers.Add(new OtherTransactionWrapper());
// This allows instrumentation that does nothing other than to track the library version.
_nonDefaultWrappers.Add(noOpWrapper);
var defaultWrappers = new List <IDefaultWrapper> {
defaultWrapper, new DefaultWrapperAsync()
};
_defaultWrappers = defaultWrappers;
_noOpTrackedWrapper = new TrackedWrapper(noOpWrapper);
if (wrappers.Count() == 0)
{
Log.Error("No wrappers were loaded. The agent will not behave as expected.");
}
if (Log.IsFinestEnabled)
{
Log.Finest($"WrapperMap has NonDefaultWrappers: {string.Join(", ", _nonDefaultWrappers)}");
}
}
public void BeforeWrappedMethod_SetsNoOpWhenThrowsExceptionTooManyTimes()
{
var wrapper = Mock.Create <IWrapper>();
var trackedWrapper = new TrackedWrapper(wrapper);
var wrapperMap = new WrapperMap(new List <IWrapper> {
wrapper
}, _defaultWrapper, _noOpWrapper);
Mock.Arrange(() => wrapper.BeforeWrappedMethod(Arg.IsAny <InstrumentedMethodCall>(), Arg.IsAny <IAgent>(), Arg.IsAny <ITransaction>())).Throws(new Exception());
Mock.Arrange(() => _configurationService.Configuration.WrapperExceptionLimit).Returns(1);
Mock.Arrange(() => _noOpWrapper.BeforeWrappedMethod(Arg.IsAny <InstrumentedMethodCall>(), Arg.IsAny <IAgent>(), Arg.IsAny <ITransaction>())).OccursOnce();
var type = typeof(System.Web.HttpApplication);
const string methodName = "ExecuteStep";
const string tracerFactoryName = "NewRelic.Agent.Core.Tracer.Factories.DefaultTracerFactory";
var invocationTarget = new object();
var arguments = new object[2];
var argumentSignature = "IExecutionStep,System.Boolean&";
var metricName = string.Empty;
var method = new Method(type, methodName, argumentSignature);
var methodCall = new MethodCall(method, invocationTarget, arguments);
var info = new InstrumentedMethodInfo(0, methodCall.Method, tracerFactoryName, false, null, null, false);
Mock.Arrange(() => wrapper.CanWrap(info)).Returns(new CanWrapResponse(true));
var wrapperService = new WrapperService(_configurationService, wrapperMap, _agent, _agentHealthReporter, _agentTimerService);
Assert.Throws <Exception>(() => wrapperService.BeforeWrappedMethod(type, methodName, argumentSignature, invocationTarget, arguments, tracerFactoryName, metricName, EmptyTracerArgs, 0));
Assert.DoesNotThrow(() => wrapperService.BeforeWrappedMethod(type, methodName, argumentSignature, invocationTarget, arguments, tracerFactoryName, metricName, EmptyTracerArgs, 0));
Mock.Assert(_noOpWrapper);
}
private void HandleBeforeWrappedMethodException(ulong functionId, TrackedWrapper trackedWrapper, InstrumentedMethodCall instrumentedMethodCall, InstrumentedMethodInfo instrumetedMethodInfo)
{
trackedWrapper.NoticeFailure();
if (trackedWrapper.NumberOfConsecutiveFailures >= _maxConsecutiveFailures)
{
_agentHealthReporter.ReportWrapperShutdown(trackedWrapper.Wrapper, instrumentedMethodCall.MethodCall.Method);
_functionIdToWrapper[functionId] = new InstrumentedMethodInfoWrapper(instrumetedMethodInfo, _wrapperMap.GetNoOpWrapper());
}
}
public void BeforeWrappedMethod_DoesNotSetNullOnFirstThrownException()
{
var wrapper = Mock.Create <IWrapper>();
var trackedWrapper = new TrackedWrapper(wrapper);
Mock.Arrange(() => wrapper.BeforeWrappedMethod(Arg.IsAny <InstrumentedMethodCall>(), Arg.IsAny <IAgent>(), Arg.IsAny <ITransaction>())).Throws(new Exception());
Mock.Arrange(() => _wrapperMap.Get(Arg.IsAny <InstrumentedMethodInfo>())).Returns(trackedWrapper);
var type = typeof(Class_WrapperService);
const string methodName = "MyMethod";
const string tracerFactoryName = "MyTracer";
var target = new object();
var arguments = new object[0];
Assert.Throws <Exception>(() => _wrapperService.BeforeWrappedMethod(type, methodName, string.Empty, target, arguments, tracerFactoryName, null, EmptyTracerArgs, 0));
Mock.Assert(_wrapperMap);
}
public InstrumentedMethodInfoWrapper(InstrumentedMethodInfo instrumentedMethodInfo, TrackedWrapper wrapper)
{
this.wrapper = wrapper;
this.instrumentedMethodInfo = instrumentedMethodInfo;
}
