[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 Task.FromResult<object>(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 = HttpSemanticConventions.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.Union(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);
+                HttpSemanticConventions.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);
+                HttpSemanticConventions.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/AWSLambdaUtils.cs

@@ -167,16 +167,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)
         {
@@ -198,6 +193,11 @@ private static IEnumerable<string> GetHeaderValues(APIGatewayProxyRequest reques
             {
                 return values;
             }
+            else if (request.Headers != null &&
+                     request.Headers.TryGetValue(name, out var value))
+            {
+                return new[] { value };
+            }
 
             return null;
         }

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

@@ -0,0 +1,49 @@
+// <copyright file="CommonExtensions.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;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace OpenTelemetry.Instrumentation.AWSLambda.Implementation
+{
+    internal static class CommonExtensions
+    {
+        internal static bool TryGetValueIgnoringCase<T>(this IDictionary<string, T> dict, string key, out T value)
+        {
+            value = default;
+            var targetKey = dict.Keys
+                .Where(s => string.Equals(s, key, StringComparison.CurrentCultureIgnoreCase))
+                .FirstOrDefault();
+
+            if (targetKey != default)
+            {
+                value = dict[targetKey];
+                return true;
+            }
+
+            return false;
+        }
+
+        internal static void AddStringTagIfNotNull(this List<KeyValuePair<string, object>> tags, string tagName, string tagValue)
+        {
+            if (tagValue != null)
+            {
+                tags.Add(new(tagName, tagValue));
+            }
+        }
+    }
+}

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

@@ -0,0 +1,140 @@
+// <copyright file="HttpSemanticConventions.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 Amazon.Lambda.APIGatewayEvents;
+using OpenTelemetry.Trace;
+
+namespace OpenTelemetry.Instrumentation.AWSLambda.Implementation
+{
+    internal class HttpSemanticConventions
+    {
+        // x-forwarded-... headres 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;
+            string hostPort = null;
+
+            switch (input)
+            {
+                case APIGatewayProxyRequest request:
+                    httpScheme = GetHeaderValue(request, HeaderXForwardedProto);
+                    httpTarget = request.Path;
+                    httpMethod = request.HttpMethod;
+                    var hostHeader = GetHeaderValue(request, HeaderHost);
+                    (hostName, hostPort) = GetHostAndPort(httpScheme, hostHeader);
+                    break;
+                case APIGatewayHttpApiV2ProxyRequest requestV2:
+                    httpScheme = GetHeaderValue(requestV2, HeaderXForwardedProto);
+                    httpTarget = requestV2?.RequestContext?.Http?.Path;
+                    httpMethod = requestV2?.RequestContext?.Http?.Method;
+                    var hostHeaderV2 = GetHeaderValue(requestV2, HeaderHost);
+                    (hostName, hostPort) = GetHostAndPort(httpScheme, hostHeaderV2);
+                    break;
+            }
+
+            tags.AddStringTagIfNotNull(SemanticConventions.AttributeHttpScheme, httpScheme);
+            tags.AddStringTagIfNotNull(SemanticConventions.AttributeHttpTarget, httpTarget);
+            tags.AddStringTagIfNotNull(SemanticConventions.AttributeHttpMethod, httpMethod);
+            tags.AddStringTagIfNotNull(SemanticConventions.AttributeNetHostName, hostName);
+            tags.AddStringTagIfNotNull(SemanticConventions.AttributeNetHostPort, hostPort);
+
+            return tags;
+        }
+
+        internal static void SetHttpTagsFromResult<TResult>(Activity activity, TResult result)
+        {
+            switch (result)
+            {
+                case APIGatewayProxyResponse response:
+                    activity.SetTag(SemanticConventions.AttributeHttpStatusCode, response.StatusCode.ToString());
+                    break;
+                case APIGatewayHttpApiV2ProxyResponse responseV2:
+                    activity.SetTag(SemanticConventions.AttributeHttpStatusCode, responseV2.StatusCode.ToString());
+                    break;
+            }
+        }
+
+        internal static (string Host, string Port) GetHostAndPort(string httpScheme, string hostHeaders)
+        {
+            if (hostHeaders == null)
+            {
+                return (null, null);
+            }
+
+            // In case of multiple headres we consider only the 1st.
+            var hostHeader = hostHeaders.Split(',').First();
+            var hostAndPort = hostHeader.Split(':');
+            if (hostAndPort.Length > 1)
+            {
+                return (hostAndPort[0], hostAndPort[1]);
+            }
+            else
+            {
+                string defaultPort = null;
+                switch (httpScheme)
+                {
+                    case "http":
+                        defaultPort = "80";
+                        break;
+                    case "https":
+                        defaultPort = "443";
+                        break;
+                }
+
+                return (hostAndPort[0], defaultPort);
+            }
+        }
+
+        private static string GetHeaderValue(APIGatewayProxyRequest request, string name)
+        {
+            if (request.MultiValueHeaders != null &&
+                request.MultiValueHeaders.TryGetValueIgnoringCase(name, out var values))
+            {
+                return string.Join(",", values);
+            }
+            else if (request.Headers != null &&
+                     request.Headers.TryGetValueIgnoringCase(name, out var value))
+            {
+                return value;
+            }
+
+            return null;
+        }
+
+        private static string GetHeaderValue(APIGatewayHttpApiV2ProxyRequest request, string name)
+        {
+            if (request.Headers != null &&
+                request.Headers.TryGetValueIgnoringCase(name, out var header))
+            {
+                // Multiple values for the same header will be separated by a comma.
+                return header;
+            }
+
+            return null;
+        }
+    }
+}

src/OpenTelemetry.Instrumentation.AWSLambda/OpenTelemetry.Instrumentation.AWSLambda.csproj

@@ -17,6 +17,7 @@
 
   <ItemGroup>
     <Compile Include="$(RepoRoot)\src\OpenTelemetry.Internal\Guard.cs" Link="Includes\Guard.cs" />
+    <Compile Include="$(RepoRoot)\src\OpenTelemetry.Contrib.Shared\Api\SemanticConventions.cs" Link="Includes\SemanticConventions.cs"/>
   </ItemGroup>
 
 </Project>