[Instrumentation.AWSLambda] Issue/aws lambda http server semantic conventions attributes

src/OpenTelemetry.Instrumentation.AWSLambda/AWSLambdaWrapper.cs

@@ -17,6 +17,7 @@
 using System;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
 using Amazon.Lambda.Core;
@@ -68,10 +69,7 @@ public static TResult Trace<TInput, TResult>(
         ILambdaContext context,
         ActivityContext parentContext = default)
     {
-        TResult result = default;
-        Action action = () => result = lambdaHandler(input, context);
-        TraceInternal(tracerProvider, action, input, context, parentContext);
-        return result;
+        return TraceInternal(tracerProvider, lambdaHandler, input, context, parentContext);
     }
 
     /// <summary>
@@ -95,8 +93,12 @@ public static void Trace<TInput>(
         ILambdaContext context,
         ActivityContext parentContext = default)
     {
-        Action action = () => lambdaHandler(input, context);
-        TraceInternal(tracerProvider, action, input, context, parentContext);
+        Func<TInput, ILambdaContext, object> func = (input, context) =>
+        {
+            lambdaHandler(input, context);
+            return null;
+        };
+        TraceInternal(tracerProvider, func, input, context, parentContext);
     }
 
     /// <summary>
@@ -121,8 +123,12 @@ public static Task TraceAsync<TInput>(
         ILambdaContext context,
         ActivityContext parentContext = default)
     {
-        Func<Task> action = async () => await lambdaHandler(input, context);
-        return TraceInternalAsync(tracerProvider, action, input, context, parentContext);
+        Func<TInput, ILambdaContext, Task<object>> func = async (input, context) =>
+        {
+            await lambdaHandler(input, context);
+            return null;
+        };
+        return TraceInternalAsync(tracerProvider, func, input, context, parentContext);
     }
 
     /// <summary>
@@ -141,17 +147,14 @@ public static Task TraceAsync<TInput>(
     /// unless X-Ray propagation is disabled in the configuration for this wrapper.
     /// </param>
     /// <returns>Task of result.</returns>
-    public static async Task<TResult> TraceAsync<TInput, TResult>(
+    public static Task<TResult> TraceAsync<TInput, TResult>(
         TracerProvider tracerProvider,
         Func<TInput, ILambdaContext, Task<TResult>> lambdaHandler,
         TInput input,
         ILambdaContext context,
         ActivityContext parentContext = default)
     {
-        TResult result = default;
-        Func<Task> action = async () => result = await lambdaHandler(input, context);
-        await TraceInternalAsync(tracerProvider, action, input, context, parentContext);
-        return result;
+        return TraceInternalAsync(tracerProvider, lambdaHandler, input, context, parentContext);
     }
 
 #pragma warning restore RS0026 // Do not add multiple public overloads with optional parameters
@@ -167,9 +170,12 @@ internal static Activity OnFunctionStart<TInput>(TInput input, ILambdaContext co
             }
         }
 
-        var tags = AWSLambdaUtils.GetFunctionTags(input, context);
+        var functionTags = AWSLambdaUtils.GetFunctionTags(input, context);
+        var httpTags = AWSLambdaHttpUtils.GetHttpTags(input);
+
+        // We assume that functionTags and httpTags have no intersection.
         var activityName = AWSLambdaUtils.GetFunctionName(context) ?? "AWS Lambda Invoke";
-        var activity = AWSLambdaActivitySource.StartActivity(activityName, ActivityKind.Server, parentContext, tags);
+        var activity = AWSLambdaActivitySource.StartActivity(activityName, ActivityKind.Server, parentContext, functionTags.Concat(httpTags));
 
         return activity;
     }
@@ -197,51 +203,55 @@ private static void OnException(Activity activity, Exception exception)
         }
     }
 
-    private static void TraceInternal<TInput>(
+    private static TResult TraceInternal<TInput, TResult>(
         TracerProvider tracerProvider,
-        Action handler,
+        Func<TInput, ILambdaContext, TResult> handler,
         TInput input,
         ILambdaContext context,
         ActivityContext parentContext = default)
     {
-        var lambdaActivity = OnFunctionStart(input, context, parentContext);
+        var activity = OnFunctionStart(input, context, parentContext);
         try
         {
-            handler();
+            var result = handler(input, context);
+            AWSLambdaHttpUtils.SetHttpTagsFromResult(activity, result);
+            return result;
         }
         catch (Exception ex)
         {
-            OnException(lambdaActivity, ex);
+            OnException(activity, ex);
 
             throw;
         }
         finally
         {
-            OnFunctionStop(lambdaActivity, tracerProvider);
+            OnFunctionStop(activity, tracerProvider);
         }
     }
 
-    private static async Task TraceInternalAsync<TInput>(
+    private static async Task<TResult> TraceInternalAsync<TInput, TResult>(
         TracerProvider tracerProvider,
-        Func<Task> handlerAsync,
+        Func<TInput, ILambdaContext, Task<TResult>> handlerAsync,
         TInput input,
         ILambdaContext context,
         ActivityContext parentContext = default)
     {
-        var lambdaActivity = OnFunctionStart(input, context, parentContext);
+        var activity = OnFunctionStart(input, context, parentContext);
         try
         {
-            await handlerAsync();
+            var result = await handlerAsync(input, context);
+            AWSLambdaHttpUtils.SetHttpTagsFromResult(activity, result);
+            return result;
         }
         catch (Exception ex)
         {
-            OnException(lambdaActivity, ex);
+            OnException(activity, ex);
 
             throw;
         }
         finally
         {
-            OnFunctionStop(lambdaActivity, tracerProvider);
+            OnFunctionStop(activity, tracerProvider);
         }
     }
 }

src/OpenTelemetry.Instrumentation.AWSLambda/Implementation/AWSLambdaHttpUtils.cs

@@ -0,0 +1,136 @@
+// <copyright file="AWSLambdaHttpUtils.cs" company="OpenTelemetry Authors">
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// </copyright>
+
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Web;
+using Amazon.Lambda.APIGatewayEvents;
+using OpenTelemetry.Trace;
+
+namespace OpenTelemetry.Instrumentation.AWSLambda.Implementation
+{
+    internal class AWSLambdaHttpUtils
+    {
+        // x-forwarded-... headers are described here https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/x-forwarded-headers.html
+        private const string HeaderXForwardedProto = "x-forwarded-proto";
+        private const string HeaderHost = "host";
+
+        internal static IEnumerable<KeyValuePair<string, object>> GetHttpTags<TInput>(TInput input)
+        {
+            var tags = new List<KeyValuePair<string, object>>();
+
+            string httpScheme = null;
+            string httpTarget = null;
+            string httpMethod = null;
+            string hostName = null;
+            int? hostPort = null;
+
+            switch (input)
+            {
+                case APIGatewayProxyRequest request:
+                    httpScheme = AWSLambdaUtils.GetHeaderValues(request, HeaderXForwardedProto)?.FirstOrDefault();
+                    httpTarget = string.Concat(request.RequestContext?.Path ?? string.Empty, GetQueryString(request));
+                    httpMethod = request.HttpMethod;
+                    var hostHeader = AWSLambdaUtils.GetHeaderValues(request, HeaderHost)?.FirstOrDefault();
+                    (hostName, hostPort) = GetHostAndPort(httpScheme, hostHeader);
+                    break;
+                case APIGatewayHttpApiV2ProxyRequest requestV2:
+                    httpScheme = AWSLambdaUtils.GetHeaderValues(requestV2, HeaderXForwardedProto)?.FirstOrDefault();
+                    httpTarget = string.Concat(requestV2.RawPath ?? string.Empty, GetQueryString(requestV2));
+                    httpMethod = requestV2.RequestContext?.Http?.Method;
+                    var hostHeaderV2 = AWSLambdaUtils.GetHeaderValues(requestV2, HeaderHost)?.FirstOrDefault();
+                    (hostName, hostPort) = GetHostAndPort(httpScheme, hostHeaderV2);
+                    break;
+            }
+
+            tags.AddTagIfNotNull(SemanticConventions.AttributeHttpScheme, httpScheme);
+            tags.AddTagIfNotNull(SemanticConventions.AttributeHttpTarget, httpTarget);
+            tags.AddTagIfNotNull(SemanticConventions.AttributeHttpMethod, httpMethod);
+            tags.AddTagIfNotNull(SemanticConventions.AttributeNetHostName, hostName);
+            tags.AddTagIfNotNull(SemanticConventions.AttributeNetHostPort, hostPort);
+
+            return tags;
+        }
+
+        internal static void SetHttpTagsFromResult(Activity activity, object result)
+        {
+            switch (result)
+            {
+                case APIGatewayProxyResponse response:
+                    activity.SetTag(SemanticConventions.AttributeHttpStatusCode, response.StatusCode);
+                    break;
+                case APIGatewayHttpApiV2ProxyResponse responseV2:
+                    activity.SetTag(SemanticConventions.AttributeHttpStatusCode, responseV2.StatusCode);
+                    break;
+            }
+        }
+
+        internal static string GetQueryString(APIGatewayProxyRequest request)
+        {
+            if (request.MultiValueQueryStringParameters == null)
+            {
+                return string.Empty;
+            }
+
+            var queryString = new StringBuilder();
+            var separator = '?';
+            foreach (var parameterKvp in request.MultiValueQueryStringParameters)
+            {
+                // Multiple values for the same parameter will be added to query
+                // as ampersand separated: name=value1&name=value2
+                foreach (var value in parameterKvp.Value)
+                {
+                    queryString.Append(separator)
+                        .Append(HttpUtility.UrlEncode(parameterKvp.Key))
+                        .Append("=")
+                        .Append(HttpUtility.UrlEncode(value));
+                    separator = '&';
+                }
+            }
+
+            return queryString.ToString();
+        }
+
+        internal static string GetQueryString(APIGatewayHttpApiV2ProxyRequest request) =>
+            string.IsNullOrEmpty(request.RawQueryString) ? string.Empty : "?" + request.RawQueryString;
+
+        internal static (string Host, int? Port) GetHostAndPort(string httpScheme, string hostHeader)
+        {
+            if (hostHeader == null)
+            {
+                return (null, null);
+            }
+
+            var hostAndPort = hostHeader.Split(new char[] { ':' }, 2);
+            if (hostAndPort.Length > 1)
+            {
+                var host = hostAndPort[0];
+                return int.TryParse(hostAndPort[1], out var port)
+                    ? (host, port)
+                    : (host, null);
+            }
+            else
+            {
+                return (hostAndPort[0], GetDefaultPort(httpScheme));
+            }
+        }
+
+        private static int? GetDefaultPort(string httpScheme) =>
+            httpScheme == "https" ? 443 : httpScheme == "http" ? 80 : null;
+    }
+}

src/OpenTelemetry.Instrumentation.AWSLambda/Implementation/AWSLambdaUtils.cs

@@ -137,6 +137,30 @@ internal static IEnumerable<KeyValuePair<string, object>> GetFunctionTags<TInput
         return tags;
     }
 
+    internal static IEnumerable<string> GetHeaderValues(APIGatewayProxyRequest request, string name)
+    {
+        var multiValueHeader = request.MultiValueHeaders?.GetValueByKeyIgnoringCase(name);
+        if (multiValueHeader != null)
+        {
+            return multiValueHeader;
+        }
+
+        var headerValue = request.Headers?.GetValueByKeyIgnoringCase(name);
+
+        return headerValue != null ? new[] { headerValue } : null;
+    }
+
+    internal static IEnumerable<string> GetHeaderValues(APIGatewayHttpApiV2ProxyRequest request, string name)
+    {
+        var headerValue = GetHeaderValue(request, name);
+
+        // Multiple values for the same header will be separated by a comma.
+        return headerValue?.Split(',');
+    }
+
+    private static string GetHeaderValue(APIGatewayHttpApiV2ProxyRequest request, string name) =>
+        request.Headers?.GetValueByKeyIgnoringCase(name);
+
     private static string GetAccountId(string functionArn)
     {
         // The fifth item of function arn: https://github.com/open-telemetry/opentelemetry-specification/blob/86aeab1e0a7e6c67be09c7f15ff25063ee6d2b5c/specification/trace/semantic_conventions/instrumentation/aws-lambda.md#all-triggers
@@ -167,16 +191,11 @@ private static string GetFaasId(string functionArn)
         return faasId;
     }
 
-    private static string GetFaasTrigger<TInput>(TInput input)
-    {
-        var trigger = "other";
-        if (input is APIGatewayProxyRequest || input is APIGatewayHttpApiV2ProxyRequest)
-        {
-            trigger = "http";
-        }
+    private static string GetFaasTrigger<TInput>(TInput input) =>
+        IsHttpRequest(input) ? "http" : "other";
 
-        return trigger;
-    }
+    private static bool IsHttpRequest<TInput>(TInput input) =>
+        input is APIGatewayProxyRequest || input is APIGatewayHttpApiV2ProxyRequest;
 
     private static ActivityContext ParseXRayTraceHeader(string rawHeader)
     {
@@ -190,27 +209,4 @@ private static ActivityContext ParseXRayTraceHeader(string rawHeader)
         var propagationContext = xrayPropagator.Extract(default, carrier, Getter);
         return propagationContext.ActivityContext;
     }
-
-    private static IEnumerable<string> GetHeaderValues(APIGatewayProxyRequest request, string name)
-    {
-        if (request.MultiValueHeaders != null &&
-            request.MultiValueHeaders.TryGetValue(name, out var values))
-        {
-            return values;
-        }
-
-        return null;
-    }
-
-    private static IEnumerable<string> GetHeaderValues(APIGatewayHttpApiV2ProxyRequest request, string name)
-    {
-        if (request.Headers != null &&
-            request.Headers.TryGetValue(name, out var header))
-        {
-            // Multiple values for the same header will be separated by a comma.
-            return header?.Split(',');
-        }
-
-        return null;
-    }
 }