/// <summary> /// Traces an asynchronous call to Elasticsearch. /// </summary> /// <typeparam name="T">Type type of the Task</typeparam> /// <param name="pipeline">The pipeline for the original method</param> /// <param name="requestData">The request data</param> /// <param name="cancellationToken">A cancellation token</param> /// <returns>The original result</returns> private static async Task <T> CallElasticsearchAsyncInternal <T>(object pipeline, object requestData, CancellationToken cancellationToken) { var genericArgument = typeof(T).GetGenericArguments()[0]; var executeAsync = CallElasticsearchAsyncAccess.GetInterceptedMethod( pipeline.GetType(), returnType: null, methodName: nameof(CallElasticsearchAsync), generics: new[] { genericArgument }, parameters: new[] { ElasticsearchNetCommon.RequestDataType, ElasticsearchNetCommon.CancellationTokenType }); using (var scope = ElasticsearchNetCommon.CreateScope(Tracer.Instance, IntegrationName, pipeline, requestData)) { try { var task = (Task <T>)executeAsync(pipeline, requestData, cancellationToken); return(await task.ConfigureAwait(false)); } catch (Exception ex) when(scope?.Span.SetExceptionForFilter(ex) ?? false) { // unreachable code throw; } } }
/// <summary> /// Traces an asynchronous call to Elasticsearch. /// </summary> /// <typeparam name="T">Type type of the Task</typeparam> /// <param name="pipeline">The pipeline for the original method</param> /// <param name="requestData">The request data</param> /// <param name="cancellationToken">A cancellation token</param> /// <param name="originalMethod">A delegate for the method we are instrumenting</param> /// <returns>The original result</returns> private static async Task <T> CallElasticsearchAsyncInternal <T>( object pipeline, object requestData, CancellationToken cancellationToken, Func <object, object, CancellationToken, object> originalMethod) { using (var scope = ElasticsearchNetCommon.CreateScope(Tracer.Instance, IntegrationName, pipeline, requestData)) { try { var task = (Task <T>)originalMethod(pipeline, requestData, cancellationToken); var returned = await task.ConfigureAwait(false); if (scope != null) { await scope.Span.SetDbStatementFromRequestDataAsync(requestData); } return(returned); } catch (Exception ex) when(scope?.Span.SetExceptionForFilter(ex) ?? false) { // unreachable code throw; } } }
public static object CallElasticsearch <TResponse>( object pipeline, object requestData, int opCode, int mdToken, long moduleVersionPtr) { if (pipeline == null) { throw new ArgumentNullException(nameof(pipeline)); } const string methodName = nameof(CallElasticsearch); Func <object, object, TResponse> callElasticSearch; var pipelineType = pipeline.GetType(); var genericArgument = typeof(TResponse); try { callElasticSearch = MethodBuilder <Func <object, object, TResponse> > .Start(moduleVersionPtr, mdToken, opCode, methodName) .WithConcreteType(pipelineType) .WithMethodGenerics(genericArgument) .WithParameters(requestData) .WithNamespaceAndNameFilters(ClrNames.Ignore, "Elasticsearch.Net.RequestData") .Build(); } catch (Exception ex) { // profiled app will not continue working as expected without this method Log.ErrorRetrievingMethod( exception: ex, moduleVersionPointer: moduleVersionPtr, mdToken: mdToken, opCode: opCode, instrumentedType: RequestPipelineInterfaceTypeName, methodName: methodName, instanceType: pipeline.GetType().AssemblyQualifiedName); throw; } using (var scope = ElasticsearchNetCommon.CreateScope(Tracer.Instance, IntegrationName, pipeline, requestData)) { try { var returned = callElasticSearch(pipeline, requestData); scope?.Span.SetDbStatementFromRequestData(requestData); return(returned); } catch (Exception ex) when(scope?.Span.SetExceptionForFilter(ex) ?? false) { // unreachable code throw; } } }
/// <summary> /// Traces an asynchronous call to Elasticsearch. /// </summary> /// <typeparam name="TResponse">Type type of the response</typeparam> /// <param name="pipeline">The pipeline for the original method</param> /// <param name="requestData">The request data</param> /// <param name="cancellationToken">A cancellation token</param> /// <param name="opCode">The OpCode used in the original method call.</param> /// <param name="mdToken">The mdToken of the original method call.</param> /// <param name="moduleVersionPtr">A pointer to the module version GUID.</param> /// <returns>The original result</returns> private static async Task <TResponse> CallElasticsearchAsyncInternal <TResponse>( object pipeline, object requestData, CancellationToken cancellationToken, int opCode, int mdToken, long moduleVersionPtr) { const string methodName = "CallElasticsearchAsync"; Func <object, object, CancellationToken, Task <TResponse> > callElasticSearchAsync; var pipelineType = pipeline.GetType(); var genericArgument = typeof(TResponse); try { callElasticSearchAsync = MethodBuilder <Func <object, object, CancellationToken, Task <TResponse> > > .Start(moduleVersionPtr, mdToken, opCode, methodName) .WithConcreteType(pipelineType) .WithMethodGenerics(genericArgument) .WithParameters(requestData, cancellationToken) .WithNamespaceAndNameFilters(ClrNames.GenericTask, "Elasticsearch.Net.RequestData", ClrNames.CancellationToken) .Build(); } catch (Exception ex) { Log.ErrorRetrievingMethod( exception: ex, moduleVersionPointer: moduleVersionPtr, mdToken: mdToken, opCode: opCode, instrumentedType: RequestPipelineInterfaceTypeName, methodName: methodName, instanceType: pipelineType.AssemblyQualifiedName); throw; } using (var scope = ElasticsearchNetCommon.CreateScope(Tracer.Instance, IntegrationName, pipeline, requestData)) { try { var returned = await callElasticSearchAsync(pipeline, requestData, cancellationToken).ConfigureAwait(false); if (scope != null) { await scope.Span.SetDbStatementFromRequestDataAsync(requestData); } return(returned); } catch (Exception ex) when(scope?.Span.SetExceptionForFilter(ex) ?? false) { // unreachable code throw; } } }
public static object CallElasticsearch <TResponse>( object pipeline, object requestData, int opCode, int mdToken, long moduleVersionPtr) { if (pipeline == null) { throw new ArgumentNullException(nameof(pipeline)); } const string methodName = nameof(CallElasticsearch); Func <object, object, object> callElasticSearch; var pipelineType = pipeline.GetType(); var genericArgument = typeof(TResponse); try { callElasticSearch = MethodBuilder <Func <object, object, object> > .Start(moduleVersionPtr, mdToken, opCode, methodName) .WithConcreteType(pipelineType) .WithMethodGenerics(genericArgument) .WithNamespaceAndNameFilters("Elasticsearch.Net.ElasticsearchResponse`1", "Elasticsearch.Net.RequestData") .WithParameters(requestData) .Build(); } catch (Exception ex) { Log.ErrorRetrievingMethod( exception: ex, moduleVersionPointer: moduleVersionPtr, mdToken: mdToken, opCode: opCode, instrumentedType: RequestPipelineInterfaceTypeName, methodName: methodName, instanceType: pipeline.GetType().AssemblyQualifiedName); throw; } using (var scope = ElasticsearchNetCommon.CreateScope(Tracer.Instance, IntegrationName, pipeline, requestData)) { try { return(callElasticSearch(pipeline, requestData)); } catch (Exception ex) { scope?.Span.SetException(ex); throw; } } }
/// <summary> /// Traces an asynchronous call to Elasticsearch. /// </summary> /// <typeparam name="TResponse">Type type of the response</typeparam> /// <param name="pipeline">The pipeline for the original method</param> /// <param name="requestData">The request data</param> /// <param name="cancellationToken">A cancellation token</param> /// <param name="opCode">The OpCode used in the original method call.</param> /// <param name="mdToken">The mdToken of the original method call.</param> /// <param name="moduleVersionPtr">A pointer to the module version GUID.</param> /// <returns>The original result</returns> private static async Task <TResponse> CallElasticsearchAsyncInternal <TResponse>( object pipeline, object requestData, CancellationToken cancellationToken, int opCode, int mdToken, long moduleVersionPtr) { const string methodName = "CallElasticsearchAsync"; Func <object, object, CancellationToken, Task <TResponse> > callElasticSearchAsync; var pipelineType = pipeline.GetType(); var genericArgument = typeof(TResponse); try { callElasticSearchAsync = MethodBuilder <Func <object, object, CancellationToken, Task <TResponse> > > .Start(moduleVersionPtr, mdToken, opCode, methodName) .WithConcreteType(pipelineType) .WithMethodGenerics(genericArgument) .WithParameters(requestData, cancellationToken) .WithNamespaceAndNameFilters(ClrNames.GenericTask, "Elasticsearch.Net.RequestData", ClrNames.CancellationToken) .Build(); } catch (Exception ex) { // profiled app will not continue working as expected without this method Log.ErrorException($"Error retrieving {pipelineType.Name}.{methodName}(RequestData requestData, CancellationToken cancellationToken)", ex); throw; } using (var scope = ElasticsearchNetCommon.CreateScope(Tracer.Instance, IntegrationName, pipeline, requestData)) { try { return(await callElasticSearchAsync(pipeline, requestData, cancellationToken).ConfigureAwait(false)); } catch (Exception ex) when(scope?.Span.SetExceptionForFilter(ex) ?? false) { // unreachable code throw; } } }
public static object CallElasticsearch <TResponse>( object pipeline, object requestData, int opCode, int mdToken, long moduleVersionPtr) { const string methodName = nameof(CallElasticsearch); Func <object, object, TResponse> callElasticSearch; var pipelineType = pipeline.GetType(); var genericArgument = typeof(TResponse); try { callElasticSearch = MethodBuilder <Func <object, object, TResponse> > .Start(moduleVersionPtr, mdToken, opCode, methodName) .WithConcreteType(pipelineType) .WithMethodGenerics(genericArgument) .WithParameters(requestData) .WithNamespaceAndNameFilters(ClrNames.Ignore, "Elasticsearch.Net.RequestData") .Build(); } catch (Exception ex) { // profiled app will not continue working as expected without this method Log.ErrorException($"Error retrieving {pipelineType.Name}.{methodName}(RequestData requestData)", ex); throw; } using (var scope = ElasticsearchNetCommon.CreateScope(Tracer.Instance, IntegrationName, pipeline, requestData)) { try { return(callElasticSearch(pipeline, requestData)); } catch (Exception ex) when(scope?.Span.SetExceptionForFilter(ex) ?? false) { // unreachable code throw; } } }
/// <summary> /// Traces an asynchronous call to Elasticsearch. /// </summary> /// <typeparam name="T">Type type of the Task</typeparam> /// <param name="pipeline">The pipeline for the original method</param> /// <param name="requestData">The request data</param> /// <param name="cancellationToken">A cancellation token</param> /// <param name="originalMethod">A delegate for the method we are instrumenting</param> /// <returns>The original result</returns> private static async Task <T> CallElasticsearchAsyncInternal <T>( object pipeline, object requestData, CancellationToken cancellationToken, Func <object, object, CancellationToken, object> originalMethod) { using (var scope = ElasticsearchNetCommon.CreateScope(Tracer.Instance, IntegrationName, pipeline, requestData)) { try { var task = (Task <T>)originalMethod(pipeline, requestData, cancellationToken); return(await task.ConfigureAwait(false)); } catch (Exception ex) { scope?.Span.SetException(ex); throw; } } }
public static object CallElasticsearch <TResponse>(object pipeline, object requestData, int opCode) { // TResponse CallElasticsearch<TResponse>(RequestData requestData) where TResponse : class, IElasticsearchResponse, new(); var originalMethod = Emit.DynamicMethodBuilder <Func <object, object, object> > .GetOrCreateMethodCallDelegate( ElasticsearchNetCommon.RequestPipelineType, "CallElasticsearch", methodGenericArguments : new[] { typeof(TResponse) }); using (var scope = ElasticsearchNetCommon.CreateScope(Tracer.Instance, IntegrationName, pipeline, requestData)) { try { return(originalMethod(pipeline, requestData)); } catch (Exception ex) when(scope?.Span.SetExceptionForFilter(ex) ?? false) { // unreachable code throw; } } }
/// <summary> /// Traces an asynchronous call to Elasticsearch. /// </summary> /// <typeparam name="TResponse">Type type of the response</typeparam> /// <param name="pipeline">The pipeline for the original method</param> /// <param name="requestData">The request data</param> /// <param name="cancellationToken">A cancellation token</param> /// <returns>The original result</returns> private static async Task<TResponse> CallElasticsearchAsyncInternal<TResponse>(object pipeline, object requestData, CancellationToken cancellationToken) { var originalMethod = Emit.DynamicMethodBuilder<Func<object, object, CancellationToken, Task<TResponse>>> .GetOrCreateMethodCallDelegate( ElasticsearchNetCommon.RequestPipelineType, "CallElasticsearchAsync", methodParameterTypes: new[] { ElasticsearchNetCommon.RequestDataType, ElasticsearchNetCommon.CancellationTokenType }, methodGenericArguments: new[] { typeof(TResponse) }); using (var scope = ElasticsearchNetCommon.CreateScope(Tracer.Instance, IntegrationName, pipeline, requestData)) { try { return await originalMethod(pipeline, requestData, cancellationToken).ConfigureAwait(false); } catch (Exception ex) when (scope?.Span.SetExceptionForFilter(ex) ?? false) { // unreachable code throw; } } }