public override void OnStopActivity(Activity activity, object payload)
        {
            if (activity.IsAllDataRequested)
            {
                activity.SetStatus(GrpcTagHelper.GetGrpcStatusCodeFromActivity(activity));
            }

            this.activitySource.Stop(activity);
        }
Exemple #2
0
        public override void OnStopActivity(Activity activity, object payload)
        {
            if (activity.IsAllDataRequested)
            {
                activity.AddTag(SpanAttributeConstants.StatusCodeKey, GrpcTagHelper.GetGrpcStatusCodeFromActivity(activity));
            }

            this.activitySource.Stop(activity);
        }
        public void GrpcTagHelper_GetGrpcStatusCodeFromActivity()
        {
            var activity = new Activity("operationName");

            activity.SetTag(GrpcTagHelper.GrpcStatusCodeTagName, "0");

            var statusCode = GrpcTagHelper.GetGrpcStatusCodeFromActivity(activity);

            Assert.Equal(StatusCode.Unset, statusCode.StatusCode);
        }
        public void GrpcTagHelper_GetGrpcStatusCodeFromEmptyActivity()
        {
            var activity = new Activity("operationName");

            bool validConversion = GrpcTagHelper.TryGetGrpcStatusCodeFromActivity(activity, out int status);

            Assert.False(validConversion);
            Assert.Equal(-1, status);
            Assert.Null(activity.GetTagValue(SemanticConventions.AttributeRpcGrpcStatusCode));
        }
Exemple #5
0
        public void GrpcTagHelper_GetGrpcStatusCodeFromActivity()
        {
            var activity = new Activity("operationName");

            activity.AddTag(GrpcTagHelper.GrpcStatusCodeTagName, "0");

            var statusCode = GrpcTagHelper.GetGrpcStatusCodeFromActivity(activity);

            Assert.Equal(StatusCanonicalCode.Ok, statusCode.CanonicalCode);
        }
        public void GrpcTagHelper_GetGrpcMethodFromActivity()
        {
            var grpcMethod = "/some.service/somemethod";
            var activity   = new Activity("operationName");

            activity.SetTag(GrpcTagHelper.GrpcMethodTagName, grpcMethod);

            var result = GrpcTagHelper.GetGrpcMethodFromActivity(activity);

            Assert.Equal(grpcMethod, result);
        }
        public override void OnStartActivity(Activity activity, object payload)
        {
            if (!this.startRequestFetcher.TryFetch(payload, out HttpRequestMessage request) || request == null)
            {
                GrpcInstrumentationEventSource.Log.NullPayload(nameof(GrpcClientDiagnosticListener), nameof(this.OnStartActivity));
                return;
            }

            if (this.options.SuppressDownstreamInstrumentation)
            {
                SuppressInstrumentationScope.Enter();
            }

            var grpcMethod = GrpcTagHelper.GetGrpcMethodFromActivity(activity);

            activity.DisplayName = grpcMethod?.Trim('/');

            this.activitySource.Start(activity, ActivityKind.Client);

            if (activity.IsAllDataRequested)
            {
                try
                {
                    this.options.Enrich?.Invoke(activity, "OnStartActivity", request);
                }
                catch (Exception ex)
                {
                    GrpcInstrumentationEventSource.Log.EnrichmentException(ex);
                }

                activity.SetTag(SemanticConventions.AttributeRpcSystem, GrpcTagHelper.RpcSystemGrpc);

                if (GrpcTagHelper.TryParseRpcServiceAndRpcMethod(grpcMethod, out var rpcService, out var rpcMethod))
                {
                    activity.SetTag(SemanticConventions.AttributeRpcService, rpcService);
                    activity.SetTag(SemanticConventions.AttributeRpcMethod, rpcMethod);

                    // Remove the grpc.method tag added by the gRPC .NET library
                    activity.SetTag(GrpcTagHelper.GrpcMethodTagName, null);
                }

                var uriHostNameType = Uri.CheckHostName(request.RequestUri.Host);
                if (uriHostNameType == UriHostNameType.IPv4 || uriHostNameType == UriHostNameType.IPv6)
                {
                    activity.SetTag(SemanticConventions.AttributeNetPeerIp, request.RequestUri.Host);
                }
                else
                {
                    activity.SetTag(SemanticConventions.AttributeNetPeerName, request.RequestUri.Host);
                }

                activity.SetTag(SemanticConventions.AttributeNetPeerPort, request.RequestUri.Port);
            }
        }
        public override void OnStopActivity(Activity activity, object payload)
        {
            if (activity.IsAllDataRequested)
            {
                activity.SetStatus(GrpcTagHelper.GetGrpcStatusCodeFromActivity(activity));

                // Remove the grpc.status_code tag added by the gRPC .NET library
                activity.SetTag(GrpcTagHelper.GrpcStatusCodeTagName, null);
            }

            this.activitySource.Stop(activity);
        }
        public void GrpcTagHelper_GetGrpcStatusCodeFromActivity()
        {
            var activity = new Activity("operationName");

            activity.SetTag(GrpcTagHelper.GrpcStatusCodeTagName, "0");

            bool validConversion = GrpcTagHelper.TryGetGrpcStatusCodeFromActivity(activity, out int status);

            Assert.True(validConversion);

            var statusCode = GrpcTagHelper.ResolveSpanStatusForGrpcStatusCode(status);

            activity.SetTag(SemanticConventions.AttributeRpcGrpcStatusCode, status);

            Assert.Equal(StatusCode.Unset, statusCode.StatusCode);
            Assert.Equal(status, activity.GetTagValue(SemanticConventions.AttributeRpcGrpcStatusCode));
        }
Exemple #10
0
        public override void OnStopActivity(Activity activity, object payload)
        {
            if (activity.IsAllDataRequested)
            {
                bool validConversion = GrpcTagHelper.TryGetGrpcStatusCodeFromActivity(activity, out int status);
                if (validConversion)
                {
                    activity.SetStatus(GrpcTagHelper.ResolveSpanStatusForGrpcStatusCode(status));

                    // setting rpc.grpc.status_code
                    activity.SetTag(SemanticConventions.AttributeRpcGrpcStatusCode, status);
                }

                // Remove the grpc.status_code tag added by the gRPC .NET library
                activity.SetTag(GrpcTagHelper.GrpcStatusCodeTagName, null);
            }

            this.activitySource.Stop(activity);
        }
        public override void OnStartActivity(Activity activity, object payload)
        {
            if (!(this.startRequestFetcher.Fetch(payload) is HttpRequestMessage request))
            {
                GrpcInstrumentationEventSource.Log.NullPayload(nameof(GrpcClientDiagnosticListener), nameof(this.OnStartActivity));
                return;
            }

            var grpcMethod = GrpcTagHelper.GetGrpcMethodFromActivity(activity);

            activity.SetKind(ActivityKind.Client);
            activity.DisplayName = grpcMethod?.Trim('/');

            this.activitySource.Start(activity);

            if (activity.IsAllDataRequested)
            {
                activity.SetCustomProperty(RequestCustomPropertyName, request);
                activity.SetTag(SemanticConventions.AttributeRpcSystem, GrpcTagHelper.RpcSystemGrpc);

                if (GrpcTagHelper.TryParseRpcServiceAndRpcMethod(grpcMethod, out var rpcService, out var rpcMethod))
                {
                    activity.SetTag(SemanticConventions.AttributeRpcService, rpcService);
                    activity.SetTag(SemanticConventions.AttributeRpcMethod, rpcMethod);
                }

                var uriHostNameType = Uri.CheckHostName(request.RequestUri.Host);
                if (uriHostNameType == UriHostNameType.IPv4 || uriHostNameType == UriHostNameType.IPv6)
                {
                    activity.SetTag(SemanticConventions.AttributeNetPeerIp, request.RequestUri.Host);
                }
                else
                {
                    activity.SetTag(SemanticConventions.AttributeNetPeerName, request.RequestUri.Host);
                }

                activity.SetTag(SemanticConventions.AttributeNetPeerPort, request.RequestUri.Port.ToString());
            }
        }
Exemple #12
0
        public override void OnStartActivity(Activity activity, object payload)
        {
            if (!(this.startRequestFetcher.Fetch(payload) is HttpRequestMessage request))
            {
                InstrumentationEventSource.Log.NullPayload(nameof(GrpcClientDiagnosticListener), nameof(this.OnStartActivity));
                return;
            }

            var grpcMethod = GrpcTagHelper.GetGrpcMethodFromActivity(activity);

            // TODO: Avoid the reflection hack once .NET ships new Activity with Kind settable.
            ActivityKindPropertyInfo.SetValue(activity, ActivityKind.Client);
            activity.DisplayName = grpcMethod?.Trim('/');

            this.activitySource.Start(activity);

            if (activity.IsAllDataRequested)
            {
                activity.AddTag(SpanAttributeConstants.RpcSystem, "grpc");

                if (GrpcTagHelper.TryParseRpcServiceAndRpcMethod(grpcMethod, out var rpcService, out var rpcMethod))
                {
                    activity.AddTag(SpanAttributeConstants.RpcService, rpcService);
                    activity.AddTag(SpanAttributeConstants.RpcMethod, rpcMethod);
                }

                var uriHostNameType = Uri.CheckHostName(request.RequestUri.Host);
                if (uriHostNameType == UriHostNameType.IPv4 || uriHostNameType == UriHostNameType.IPv6)
                {
                    activity.AddTag(SpanAttributeConstants.NetPeerIp, request.RequestUri.Host);
                }
                else
                {
                    activity.AddTag(SpanAttributeConstants.NetPeerName, request.RequestUri.Host);
                }

                activity.AddTag(SpanAttributeConstants.NetPeerPort, request.RequestUri.Port.ToString());
            }
        }
Exemple #13
0
        public override void OnStartActivity(Activity activity, object payload)
        {
            if (!this.startRequestFetcher.TryFetch(payload, out HttpRequestMessage request) || request == null)
            {
                GrpcInstrumentationEventSource.Log.NullPayload(nameof(GrpcClientDiagnosticListener), nameof(this.OnStartActivity));
                return;
            }

            if (this.options.SuppressDownstreamInstrumentation)
            {
                SuppressInstrumentationScope.Enter();

                // If we are suppressing downstream instrumentation then inject
                // context here. Grpc.Net.Client uses HttpClient, so
                // SuppressDownstreamInstrumentation means that the
                // OpenTelemetry instrumentation for HttpClient will not be
                // invoked.

                // Note that HttpClient natively generates its own activity and
                // propagates W3C trace context headers regardless of whether
                // OpenTelemetry HttpClient instrumentation is invoked.
                // Therefore, injecting here preserves more intuitive span
                // parenting - i.e., the entry point span of a downstream
                // service would be parented to the span generated by
                // Grpc.Net.Client rather than the span generated natively by
                // HttpClient. Injecting here also ensures that baggage is
                // propagated to downstream services.
                // Injecting context here also ensures that the configured
                // propagator is used, as HttpClient by itself will only
                // do TraceContext propagation.
                var textMapPropagator = Propagators.DefaultTextMapPropagator;
                textMapPropagator.Inject(
                    new PropagationContext(activity.Context, Baggage.Current),
                    request,
                    HttpRequestMessageContextPropagation.HeaderValueSetter);
            }

            var grpcMethod = GrpcTagHelper.GetGrpcMethodFromActivity(activity);

            activity.DisplayName = grpcMethod?.Trim('/');

            this.activitySource.Start(activity, ActivityKind.Client, ActivitySource);

            if (activity.IsAllDataRequested)
            {
                try
                {
                    this.options.Enrich?.Invoke(activity, "OnStartActivity", request);
                }
                catch (Exception ex)
                {
                    GrpcInstrumentationEventSource.Log.EnrichmentException(ex);
                }

                activity.SetTag(SemanticConventions.AttributeRpcSystem, GrpcTagHelper.RpcSystemGrpc);

                if (GrpcTagHelper.TryParseRpcServiceAndRpcMethod(grpcMethod, out var rpcService, out var rpcMethod))
                {
                    activity.SetTag(SemanticConventions.AttributeRpcService, rpcService);
                    activity.SetTag(SemanticConventions.AttributeRpcMethod, rpcMethod);

                    // Remove the grpc.method tag added by the gRPC .NET library
                    activity.SetTag(GrpcTagHelper.GrpcMethodTagName, null);
                }

                var uriHostNameType = Uri.CheckHostName(request.RequestUri.Host);
                if (uriHostNameType == UriHostNameType.IPv4 || uriHostNameType == UriHostNameType.IPv6)
                {
                    activity.SetTag(SemanticConventions.AttributeNetPeerIp, request.RequestUri.Host);
                }
                else
                {
                    activity.SetTag(SemanticConventions.AttributeNetPeerName, request.RequestUri.Host);
                }

                activity.SetTag(SemanticConventions.AttributeNetPeerPort, request.RequestUri.Port);
            }
        }