/// <summary>
 /// OnMethodBegin callback
 /// </summary>
 /// <typeparam name="TTarget">Type of the target</typeparam>
 /// <param name="instance">Instance value, aka `this` of the instrumented method.</param>
 /// <returns>Calltarget state value</returns>
 public static CallTargetState OnMethodBegin <TTarget>(TTarget instance)
 {
     // If we are already in a consumer scope, close it.
     KafkaIntegration.CloseConsumerTransaction(Agent.Instance);
     return(CallTargetState.GetDefault());
 }
 /// <summary>
 /// OnMethodEnd callback
 /// </summary>
 /// <typeparam name="TTarget">Type of the target</typeparam>
 /// <typeparam name="TReturn">Type of the return value</typeparam>
 /// <param name="instance">Instance value, aka `this` of the instrumented method.</param>
 /// <param name="returnValue">Task of HttpResponse message instance</param>
 /// <param name="exception">Exception instance in case the original code threw an exception.</param>
 /// <param name="state">Calltarget state value</param>
 /// <returns>A response value, in an async scenario will be T of Task of T</returns>
 public static CallTargetReturn <TReturn> OnMethodEnd <TTarget, TReturn>(TTarget instance, TReturn returnValue, Exception exception, CallTargetState state)
 {
     state.Scope.DisposeWithException(exception);
     return(new CallTargetReturn <TReturn>(returnValue));
 }
示例#3
0
        /// <summary>
        /// OnAsyncMethodEnd callback
        /// </summary>
        /// <typeparam name="TTarget">Type of the target</typeparam>
        /// <typeparam name="TReturn">Type of the return value, in an async scenario will be T of Task of T</typeparam>
        /// <param name="instance">Instance value, aka `this` of the instrumented method.</param>
        /// <param name="returnValue">Return value instance</param>
        /// <param name="exception">Exception instance in case the original code threw an exception.</param>
        /// <param name="state">Calltarget state value</param>
        /// <returns>A response value, in an async scenario will be T of Task of T</returns>
        public static TReturn OnAsyncMethodEnd <TTarget, TReturn>(TTarget instance, TReturn returnValue, Exception exception, CallTargetState state)
        {
            DbSpanFactory <TTarget> .EndSpan(Agent.Instance, (IDbCommand)instance, (ISpan)state.Segment, exception);

            return(returnValue);
        }
 internal static CallTargetReturn Invoke(TTarget instance, Exception exception, CallTargetState state)
 {
     return(_invokeDelegate(instance, exception, state));
 }
示例#5
0
        /// <summary>
        /// OnMethodEnd callback
        /// </summary>
        /// <typeparam name="TTarget">Type of the target</typeparam>
        /// <param name="instance">Instance value, aka `this` of the instrumented method.</param>
        /// <param name="exception">Exception instance in case the original code threw an exception.</param>
        /// <param name="state">Calltarget state value</param>
        /// <returns>Return value of the method</returns>
        public static CallTargetReturn OnMethodEnd <TTarget>(TTarget instance, Exception exception, CallTargetState state)
        {
            if (!Tracer.Instance.Settings.IsIntegrationEnabled(IntegrationName))
            {
                return(CallTargetReturn.GetDefault());
            }

            SynchronizationContext context = SynchronizationContext.Current;

            try
            {
                SynchronizationContext.SetSynchronizationContext(null);
                // We have to ensure the flush of the buffer after we finish the tests of an assembly.
                // For some reason, sometimes when all test are finished none of the callbacks to handling the tracer disposal is triggered.
                // So the last spans in buffer aren't send to the agent.
                // Other times we reach the 500 items of the buffer in a sec and the tracer start to drop spans.
                // In a test scenario we must keep all spans.
                Tracer.Instance.FlushAsync().GetAwaiter().GetResult();
            }
            finally
            {
                SynchronizationContext.SetSynchronizationContext(context);
            }

            return(CallTargetReturn.GetDefault());
        }
 /// <summary>
 /// OnMethodEnd callback
 /// </summary>
 /// <typeparam name="TTarget">Type of the target</typeparam>
 /// <typeparam name="TResponse">Type of the response</typeparam>
 /// <param name="instance">Instance value, aka `this` of the instrumented method.</param>
 /// <param name="responseMessage">HttpResponse message instance</param>
 /// <param name="exception">Exception instance in case the original code threw an exception.</param>
 /// <param name="state">Calltarget state value</param>
 /// <returns>A response value, in an async scenario will be T of Task of T</returns>
 public static CallTargetReturn <TResponse> OnMethodEnd <TTarget, TResponse>(TTarget instance, TResponse responseMessage, Exception exception, CallTargetState state)
     where TResponse : IHttpResponseMessage
 {
     return(new CallTargetReturn <TResponse>(HttpMessageHandlerCommon.OnMethodEnd(instance, responseMessage, exception, state)));
 }
 static BeginMethodHandler()
 {
     try
     {
         DynamicMethod dynMethod = IntegrationMapper.CreateBeginMethodDelegate(typeof(TIntegration), typeof(TTarget), new[] { typeof(TArg1), typeof(TArg2), typeof(TArg3), typeof(TArg4), typeof(TArg5), typeof(TArg6) });
         if (dynMethod != null)
         {
             _invokeDelegate = (InvokeDelegate)dynMethod.CreateDelegate(typeof(InvokeDelegate));
         }
     }
     catch (Exception ex)
     {
         throw new CallTargetInvokerException(ex);
     }
     finally
     {
         if (_invokeDelegate is null)
         {
             _invokeDelegate = (instance, arg1, arg2, arg3, arg4, arg5, arg6) => CallTargetState.GetDefault();
         }
     }
 }
示例#8
0
        /// <summary>
        /// OnAsyncMethodEnd callback
        /// </summary>
        /// <typeparam name="TTarget">Type of the target</typeparam>
        /// <typeparam name="TResponse">Type of the response, in an async scenario will be T of Task of T</typeparam>
        /// <param name="instance">Instance value, aka `this` of the instrumented method.</param>
        /// <param name="responseMessage">HttpResponse message instance</param>
        /// <param name="exception">Exception instance in case the original code threw an exception.</param>
        /// <param name="state">Calltarget state value</param>
        /// <returns>A response value, in an async scenario will be T of Task of T</returns>
        public static TResponse OnAsyncMethodEnd <TTarget, TResponse>(TTarget instance, TResponse responseMessage, Exception exception, CallTargetState state)
            where TResponse : IHttpResponseMessage
        {
            Scope scope = state.Scope;

            if (scope is null)
            {
                return(responseMessage);
            }

            try
            {
                scope.Span.SetHttpStatusCode(responseMessage.StatusCode, isServer: false);

                if (exception != null)
                {
                    scope.Span.SetException(exception);
                }
            }
            finally
            {
                scope.Dispose();
            }

            return(responseMessage);
        }
        private static CallTargetState CreateCosmosDbCallState <TTarget, TQueryDefinition>(TTarget instance, TQueryDefinition queryDefinition, string containerId, string databaseId, string endpoint)
        {
            if (!Tracer.Instance.Settings.IsIntegrationEnabled(IntegrationId))
            {
                // integration disabled, don't create a scope, skip this trace
                return(CallTargetState.GetDefault());
            }

            try
            {
                string query;
                if (queryDefinition is string queryDefinitionString)
                {
                    query = queryDefinitionString;
                }
                else
                {
                    var success = queryDefinition.TryDuckCast <QueryDefinitionStruct>(out var queryDefinitionObj);
                    query = queryDefinitionObj.QueryText;
                }

                var tracer = Tracer.Instance;

                var parent = tracer.ActiveScope?.Span;

                if (parent != null &&
                    parent.Type == SpanTypes.Sql &&
                    parent.GetTag(Tags.DbType) == "cosmosdb" &&
                    parent.ResourceName == query)
                {
                    // we are already instrumenting this,
                    // don't instrument nested methods that belong to the same stacktrace
                    return(new CallTargetState(null));
                }

                var tags = new CosmosDbTags
                {
                    ContainerId = containerId,
                    DatabaseId  = databaseId,
                    Host        = endpoint,
                    DbType      = "cosmosdb",
                };

                tags.SetAnalyticsSampleRate(IntegrationId, tracer.Settings, enabledWithGlobalSetting: false);

                var serviceName = tracer.Settings.GetServiceName(tracer, ServiceName);
                var scope       = tracer.StartActiveInternal(OperationName, tags: tags, serviceName: serviceName);

                var span = scope.Span;

                span.ResourceName = query;
                span.Type         = SpanTypes.Sql;
                tracer.TracerManager.Telemetry.IntegrationGeneratedSpan(IntegrationId);

                return(new CallTargetState(scope));
            }
            catch (Exception ex)
            {
                Log.Error(ex, "Error creating or populating scope.");
            }

            return(new CallTargetState(null));
        }
 internal static CallTargetState Invoke(TTarget instance, TArg1 arg1, TArg2 arg2, TArg3 arg3)
 {
     return(CallTargetState.WithPreviousScope(Tracer.Instance.ActiveScope, _invokeDelegate(instance, arg1, arg2, arg3)));
 }
        public static CallTargetReturn OnMethodEnd <TTarget>(TTarget instance, Exception exception, CallTargetState state)
        {
            CallTargetReturn returnValue = CallTargetReturn.GetDefault();

            Console.WriteLine($"ProfilerOK: EndMethod(0)<{typeof(Noop1ArgumentsVoidIntegration)}, {typeof(TTarget)}>({instance}, {exception?.ToString() ?? "(null)"}, {state})");
            if (instance?.GetType().Name.Contains("ThrowOnEnd") == true)
            {
                Console.WriteLine("Exception thrown.");
                throw new Exception();
            }

            return(returnValue);
        }
 /// <summary>
 /// OnMethodEnd callback
 /// </summary>
 /// <typeparam name="TTarget">Type of the target</typeparam>
 /// <param name="instance">Instance value, aka `this` of the instrumented method.</param>
 /// <param name="exception">Exception instance in case the original code threw an exception.</param>
 /// <param name="state">Calltarget state value</param>
 /// <returns>CallTargetReturn</returns>
 public static CallTargetReturn OnMethodEnd <TTarget>(TTarget instance, Exception exception, CallTargetState state)
 {
     state.Scope.DisposeWithException(exception);
     return(CallTargetReturn.GetDefault());
 }
示例#13
0
        public static TReturn OnAsyncMethodEnd <TTarget, TReturn>(TTarget instance, TReturn returnValue, Exception exception, CallTargetState state)
            where TTarget : IInstance, IDuckType
            where TReturn : IReturnValue, IDuckType
        {
            string msg = $"{returnValue} {nameof(Noop7ArgumentsIntegration)}.OnAsyncMethodEnd<{typeof(TTarget).FullName}, {typeof(TReturn).FullName}>({instance}, {returnValue}, {exception}, {state})";

            Console.WriteLine(msg);
            return(returnValue);
        }
 /// <summary>
 /// OnMethodEnd callback
 /// </summary>
 /// <typeparam name="TTarget">Type of the target</typeparam>
 /// <param name="instance">Instance value, aka `this` of the instrumented method.</param>
 /// <param name="exception">Exception instance in case the original code threw an exception.</param>
 /// <param name="state">Calltarget state value</param>
 /// <returns>A response value, in an async scenario will be T of Task of T</returns>
 public static CallTargetReturn OnMethodEnd <TTarget>(TTarget instance, Exception exception, CallTargetState state) =>
 CallTargetReturn.GetDefault();
示例#15
0
 public static TReturn OnAsyncMethodEnd <TTarget, TReturn>(TTarget instance, TReturn returnValue, Exception exception, CallTargetState state)
 {
     return(returnValue);
 }
        /// <summary>
        /// OnAsyncMethodEnd callback
        /// </summary>
        /// <typeparam name="TTarget">Type of the target</typeparam>
        /// <typeparam name="TResponse">Type of the response, in an async scenario will be T of Task of T</typeparam>
        /// <param name="instance">Instance value, aka `this` of the instrumented method.</param>
        /// <param name="responseMessage">HttpResponse message instance</param>
        /// <param name="exception">Exception instance in case the original code threw an exception.</param>
        /// <param name="state">Calltarget state value</param>
        /// <returns>A response value, in an async scenario will be T of Task of T</returns>
        public static TResponse OnAsyncMethodEnd <TTarget, TResponse>(TTarget instance, TResponse responseMessage, Exception exception, CallTargetState state)
        {
            var scope = state.Scope;

            if (scope is null)
            {
                return(responseMessage);
            }

            var controllerContext = (IHttpControllerContext)state.State;

            // some fields aren't set till after execution, so populate anything missing
            AspNetWebApi2Integration.UpdateSpan(controllerContext, scope.Span, (AspNetTags)scope.Span.Tags, Enumerable.Empty <KeyValuePair <string, string> >());

            if (exception != null)
            {
                scope.Span.SetException(exception);

                // We don't have access to the final status code at this point
                // Ask the HttpContext to call us back to that we can get it
                var httpContext = HttpContext.Current;

                if (httpContext != null)
                {
                    // We don't know how long it'll take for ASP.NET to invoke the callback,
                    // so we store the real finish time
                    var now = scope.Span.Context.TraceContext.UtcNow;
                    httpContext.AddOnRequestCompleted(h => OnRequestCompleted(h, scope, now));
                }
                else
                {
                    // Looks like we won't be able to get the final status code
                    scope.Dispose();
                }
            }
            else
            {
                var httpContext = HttpContext.Current;
                if (httpContext != null && HttpRuntime.UsingIntegratedPipeline)
                {
                    scope.Span.SetHeaderTags <IHeadersCollection>(httpContext.Response.Headers.Wrap(), Tracer.Instance.Settings.HeaderTags, defaultTagPrefix: SpanContextPropagator.HttpResponseHeadersTagPrefix);
                }

                scope.Span.SetHttpStatusCode(responseMessage.DuckCast <HttpResponseMessageStruct>().StatusCode, isServer: true);
                scope.Dispose();
            }

            return(responseMessage);
        }
示例#17
0
        public async Task ExceptionGenericTest()
        {
            Exception ex = null;

            // Normal
            ex = await Assert.ThrowsAsync <CustomException>(() => GetPreviousTask().AsTask());

            Assert.Equal("Internal Test Exception", ex.Message);

            // Using the continuation
            var tcg = new ValueTaskContinuationGenerator <ValueTaskContinuationGeneratorTests, ValueTaskContinuationGeneratorTests, ValueTask <bool>, bool>();

            ex = await Assert.ThrowsAsync <CustomException>(() => tcg.SetContinuation(this, GetPreviousTask(), null, CallTargetState.GetDefault()).AsTask());

            Assert.Equal("Internal Test Exception", ex.Message);

            async ValueTask <bool> GetPreviousTask()
            {
                await Task.Delay(1000).ConfigureAwait(false);

                throw new CustomException("Internal Test Exception");
            }
        }
示例#18
0
 /// <summary>
 /// OnMethodEnd callback
 /// </summary>
 /// <typeparam name="TTarget">Type of the target</typeparam>
 /// <typeparam name="TResult">Type of the result</typeparam>
 /// <param name="instance">Instance value, aka `this` of the instrumented method.</param>
 /// <param name="messageResult">message result</param>
 /// <param name="exception">Exception instance in case the original code threw an exception.</param>
 /// <param name="state">Calltarget state value</param>
 /// <returns>CallTargetReturn</returns>
 public static CallTargetReturn <TResult> OnMethodEnd <TTarget, TResult>(TTarget instance, TResult messageResult, Exception exception, CallTargetState state)
 {
     state.Scope.DisposeWithException(exception);
     return(new CallTargetReturn <TResult>(messageResult));
 }
        /// <summary>
        /// OnAsyncMethodEnd callback
        /// </summary>
        /// <typeparam name="TTarget">Type of the target</typeparam>
        /// <param name="instance">Instance value, aka `this` of the instrumented method.</param>
        /// <param name="returnValue">Return value</param>
        /// <param name="exception">Exception instance in case the original code threw an exception.</param>
        /// <param name="state">Calltarget state value</param>
        /// <returns>A response value, in an async scenario will be T of Task of T</returns>
        public static decimal OnAsyncMethodEnd <TTarget>(TTarget instance, decimal returnValue, Exception exception, CallTargetState state)
        {
            Scope scope = state.Scope;

            if (scope != null)
            {
                TestInvokerStruct invokerInstance = instance.As <TestInvokerStruct>();
                XUnitIntegration.FinishScope(scope, invokerInstance.Aggregator);
            }

            return(returnValue);
        }
    internal static CallTargetReturn <TReturn> Invoke(TTarget instance, TReturn returnValue, Exception exception, CallTargetState state)
    {
        if (_continuationGenerator != null)
        {
            returnValue = _continuationGenerator.SetContinuation(instance, returnValue, exception, state);

            // Restore previous scope if there is a continuation
            // This is used to mimic the ExecutionContext copy from the StateMachine
            Activity.Current = state.PreviousActivity;
        }

        if (_invokeDelegate != null)
        {
            CallTargetReturn <TReturn> returnWrap = _invokeDelegate(instance, returnValue, exception, state);
            returnValue = returnWrap.GetReturnValue();
        }

        return(new CallTargetReturn <TReturn>(returnValue));
    }
        internal static CallTargetReturn <TReturn> Invoke(TTarget instance, TReturn returnValue, Exception exception, CallTargetState state)
        {
            if (_continuationGenerator != null)
            {
                returnValue = _continuationGenerator.SetContinuation(instance, returnValue, exception, state);
            }

            if (_invokeDelegate != null)
            {
                CallTargetReturn <TReturn> returnWrap = _invokeDelegate(instance, returnValue, exception, state);
                returnValue = returnWrap.GetReturnValue();
            }

            return(new CallTargetReturn <TReturn>(returnValue));
        }
示例#22
0
        /// <summary>
        /// OnAsyncMethodEnd callback
        /// </summary>
        /// <typeparam name="TTarget">Type of the target</typeparam>
        /// <typeparam name="TReturn">Type of the return value</typeparam>
        /// <param name="instance">Instance value, aka `this` of the instrumented method.</param>
        /// <param name="returnValue">Return value</param>
        /// <param name="exception">Exception instance in case the original code threw an exception.</param>
        /// <param name="state">Calltarget state value</param>
        /// <returns>A response value, in an async scenario will be T of Task of T</returns>
        public static TReturn OnAsyncMethodEnd <TTarget, TReturn>(TTarget instance, TReturn returnValue, Exception exception, CallTargetState state)
        {
            var scope = state.Scope;

            scope.DisposeWithException(exception);

            return(returnValue);
        }
示例#23
0
 /// <summary>
 /// OnMethodBegin callback
 /// </summary>
 /// <typeparam name="TTarget">Type of the target</typeparam>
 /// <param name="instance">Instance value, aka `this` of the instrumented method.</param>
 /// <returns>Calltarget state value</returns>
 public static CallTargetState OnMethodBegin <TTarget>(TTarget instance)
 {
     return(CallTargetState.GetDefault());
 }
示例#24
0
 /// <summary>
 /// OnMethodBegin callback
 /// </summary>
 /// <typeparam name="TTarget">Type of the target</typeparam>
 /// <param name="instance">Instance value, aka `this` of the instrumented method.</param>
 /// <returns>Calltarget state value</returns>
 internal static CallTargetState OnMethodBegin <TTarget>(TTarget instance)
 {
     // If we are already in a consumer scope, close it.
     KafkaHelper.CloseConsumerScope(Tracer.Instance);
     return(CallTargetState.GetDefault());
 }
        /// <summary>
        /// OnAsyncMethodEnd callback
        /// </summary>
        /// <typeparam name="TTarget">Type of the target</typeparam>
        /// <typeparam name="TReturn">Type of the return value</typeparam>
        /// <param name="instance">Instance value, aka `this` of the instrumented method.</param>
        /// <param name="returnValue">Return value</param>
        /// <param name="exception">Exception instance in case the original code threw an exception.</param>
        /// <param name="state">Calltarget state value</param>
        /// <returns>A response value, in an async scenario will be T of Task of T</returns>
        public static CallTargetReturn <TReturn> OnMethodEnd <TTarget, TReturn>(TTarget instance, TReturn returnValue, Exception exception, CallTargetState state)
        {
            if (MsTestIntegration.IsEnabled)
            {
                Scope scope = state.Scope;
                if (scope != null)
                {
                    Array returnValueArray = returnValue as Array;
                    if (returnValueArray.Length == 1)
                    {
                        object testResultObject = returnValueArray.GetValue(0);
                        if (testResultObject != null &&
                            testResultObject.TryDuckCast <TestResultStruct>(out var testResult))
                        {
                            string errorMessage    = null;
                            string errorStackTrace = null;

                            if (testResult.TestFailureException != null)
                            {
                                Exception testException     = testResult.TestFailureException.InnerException ?? testResult.TestFailureException;
                                string    testExceptionName = testException.GetType().Name;
                                if (testExceptionName != "UnitTestAssertException" && testExceptionName != "AssertInconclusiveException")
                                {
                                    scope.Span.SetException(testException);
                                }

                                errorMessage    = testException.Message;
                                errorStackTrace = testException.ToString();
                            }

                            switch (testResult.Outcome)
                            {
                            case UnitTestOutcome.Error:
                            case UnitTestOutcome.Failed:
                            case UnitTestOutcome.Timeout:
                                scope.Span.SetTag(TestTags.Status, TestTags.StatusFail);
                                scope.Span.Error = true;
                                scope.Span.SetTag(Tags.ErrorMsg, errorMessage);
                                scope.Span.SetTag(Tags.ErrorStack, errorStackTrace);
                                break;

                            case UnitTestOutcome.Inconclusive:
                            case UnitTestOutcome.NotRunnable:
                                scope.Span.SetTag(TestTags.Status, TestTags.StatusSkip);
                                scope.Span.SetTag(TestTags.SkipReason, errorMessage);
                                break;

                            case UnitTestOutcome.Passed:
                                scope.Span.SetTag(TestTags.Status, TestTags.StatusPass);
                                break;
                            }
                        }
                    }

                    if (exception != null)
                    {
                        scope.Span.SetException(exception);
                        scope.Span.SetTag(TestTags.Status, TestTags.StatusFail);
                    }

                    scope.Dispose();
                }
            }

            return(new CallTargetReturn <TReturn>(returnValue));
        }
示例#26
0
 /// <summary>
 /// OnMethodBegin callback
 /// </summary>
 /// <typeparam name="TTarget">Type of the target</typeparam>
 /// <typeparam name="TTestMethod">Type of the ITestMethod</typeparam>
 /// <param name="instance">Instance value, aka `this` of the instrumented method.</param>
 /// <param name="testMethod">Test method instance</param>
 /// <returns>Calltarget state value</returns>
 public static CallTargetState OnMethodBegin <TTarget, TTestMethod>(TTarget instance, TTestMethod testMethod)
 {
     return(CallTargetState.GetDefault());
 }
示例#27
0
        public static TReturn OnAsyncMethodEnd <TTarget, TReturn>(TTarget instance, TReturn returnValue, Exception exception, CallTargetState state)
            where TTarget : IInstance, IDuckType
            where TReturn : IReturnValue
        {
            Console.WriteLine($"ProfilerOK: EndMethodAsync(1)<{typeof(Noop2ArgumentsIntegration)}, {typeof(TTarget)}, {typeof(TReturn)}>({instance}, {returnValue}, {exception?.ToString() ?? "(null)"}, {state})");
            if (instance.Instance?.GetType().Name.Contains("ThrowOnAsyncEnd") == true)
            {
                Console.WriteLine("Exception thrown.");
                throw new Exception();
            }

            return(returnValue);
        }
示例#28
0
        /// <summary>
        /// OnAsyncMethodEnd callback
        /// </summary>
        /// <typeparam name="TTarget">Type of the target</typeparam>
        /// <typeparam name="TReturn">Type of the return value</typeparam>
        /// <param name="instance">Instance value, aka `this` of the instrumented method.</param>
        /// <param name="returnValue">Return value</param>
        /// <param name="exception">Exception instance in case the original code threw an exception.</param>
        /// <param name="state">Calltarget state value</param>
        /// <returns>A response value, in an async scenario will be T of Task of T</returns>
        public static CallTargetReturn <TReturn> OnMethodEnd <TTarget, TReturn>(TTarget instance, TReturn returnValue, Exception exception, CallTargetState state)
        {
            if (Common.TestTracer.Settings.IsIntegrationEnabled(IntegrationId))
            {
                Scope scope = Common.TestTracer.ActiveScope;
                if (scope != null)
                {
                    Array returnValueArray = returnValue as Array;
                    if (returnValueArray.Length == 1)
                    {
                        object testResultObject = returnValueArray.GetValue(0);
                        if (testResultObject != null &&
                            testResultObject.TryDuckCast <TestResultStruct>(out var testResult) &&
                            testResult.TestFailureException != null)
                        {
                            Exception testException     = testResult.TestFailureException.InnerException ?? testResult.TestFailureException;
                            string    testExceptionName = testException.GetType().Name;
                            if (testExceptionName != "UnitTestAssertException" && testExceptionName != "AssertInconclusiveException")
                            {
                                scope.Span.SetException(testException);
                            }
                        }
                    }

                    if (exception != null)
                    {
                        scope.Span.SetException(exception);
                    }
                }
            }

            return(new CallTargetReturn <TReturn>(returnValue));
        }
示例#29
0
        public override TReturn SetContinuation(TTarget instance, TReturn returnValue, Exception exception, CallTargetState state)
        {
            if (_continuation == null)
            {
                return(returnValue);
            }

            if (exception != null || returnValue == null)
            {
                _continuation(instance, default, exception, state);
示例#30
0
 static BeginMethodHandler()
 {
     try
     {
         Type          tArg1ByRef = typeof(TArg1).IsByRef ? typeof(TArg1) : typeof(TArg1).MakeByRefType();
         Type          tArg2ByRef = typeof(TArg2).IsByRef ? typeof(TArg2) : typeof(TArg2).MakeByRefType();
         Type          tArg3ByRef = typeof(TArg3).IsByRef ? typeof(TArg3) : typeof(TArg3).MakeByRefType();
         Type          tArg4ByRef = typeof(TArg4).IsByRef ? typeof(TArg4) : typeof(TArg4).MakeByRefType();
         Type          tArg5ByRef = typeof(TArg5).IsByRef ? typeof(TArg5) : typeof(TArg5).MakeByRefType();
         Type          tArg6ByRef = typeof(TArg6).IsByRef ? typeof(TArg6) : typeof(TArg6).MakeByRefType();
         DynamicMethod dynMethod  = IntegrationMapper.CreateBeginMethodDelegate(typeof(TIntegration), typeof(TTarget), new[] { tArg1ByRef, tArg2ByRef, tArg3ByRef, tArg4ByRef, tArg5ByRef, tArg6ByRef });
         if (dynMethod != null)
         {
             _invokeDelegate = (InvokeDelegate)dynMethod.CreateDelegate(typeof(InvokeDelegate));
         }
     }
     catch (Exception ex)
     {
         throw new CallTargetInvokerException(ex);
     }
     finally
     {
         if (_invokeDelegate is null)
         {
             _invokeDelegate = (TTarget instance, ref TArg1 arg1, ref TArg2 arg2, ref TArg3 arg3, ref TArg4 arg4, ref TArg5 arg5, ref TArg6 arg6) => CallTargetState.GetDefault();
         }
     }
 }