tracez votre fonction .NET Lambda avec New Relic et OpenTelemetry

Installer la couche

AWS publie une couche gérée qui inclut OpenTelemetry Lambda Collector.

Pour l'installer :

1. Ouvrez votre fonction dans la console Lambda.

2. Sous Layers dans la section Designer , choisissez Add a layer.

3. Sous Specify an ARN, collez l’un des ARN de couche pour l’architecture de votre fonction à partir de la liste ci-dessous. Remplacez {region}par votre région AWS, par exemple us-east-1.

4. Choisissez Add.

   • AMD64 / X86_64: arn:aws:lambda:{region}:901920570463:layer:aws-otel-collector-amd64-ver-0-90-1:1
   • ARM64: arn:aws:lambda:\<region>:901920570463:layer:aws-otel-collector-arm64-ver-0-90-1:1

   Pour les modèles SAM et CloudFormation, ajoutez les éléments suivants aux propriétés de votre fonction :

   yourFunctionHere:
     Type: AWS::Serverless::Function
     Properties:
       # ...
       Layers:
         # Use this if using x86_64 architecture
         - !Sub arn:${AWS::Partition}:lambda:${AWS::Region}:901920570463:layer:aws-otel-collector-amd64-ver-0-90-1:1
         # Use this if using arm64 architecture
         - !Sub arn:${AWS::Partition}:lambda:${AWS::Region}:901920570463:layer:aws-otel-collector-arm64-ver-0-90-1:1

   Copier

   Important

   Reportez-vous aux derniers ARN publiés par AWS pour vérifier que les ARN de couche ci-dessus sont à jour.

Ajouter des variables d'environnement New Relic

Pour envoyer les OpenTelemetry données que cette couche collecte à New Relic, nous devons configurer le OpenTelemetry Lambda Collector fourni avec la couche pour exporter la télémétrie qu'il reçoit vers le point de terminaison de New Relic OpenTelemetry . Avant de faire cela, nous devons d’abord définir certaines variables d’environnement dont cela dépendra.

1. Générez et copiez une New Relic clé de licenceà partir de votre compte New Relic.
2. Ouvrez votre fonction dans la console Lambda.
3. Choisissez Configuration puis Environment variables.
4. Sous Environment variables, choisissez Edit.
5. Choisissez Add environment variable.
6. Pour le Key définissez-le sur NEW_RELIC_LICENSE_KEY et définissez le Value sur la valeur de la clé de licence que vous avez générée à l'étape 1. Choisissez ensuite Save.
7. Choisissez à nouveau Add environment variable .
8. Pour le Key définissez-le sur NEW_RELIC_OPENTELEMETRY_ENDPOINT et définissez le Value sur l'une des options ci-dessous (dépend de votre région New Relic). Choisissez ensuite Save.
9. Choisissez à nouveau Add environment variable .
10. Pour le Key définissez-le sur OTEL_SERVICE_NAME et définissez le Value sur le nom de votre fonction. Choisissez ensuite Save.

• otlp.nr-data.net:4317:Si votre compte New Relic se trouve dans la région des États-Unis

• otlp.eu01.nr-data.net:4317:Si votre compte New Relic se trouve dans la région UE

  Pour les modèles SAM et CloudFormation, ajoutez les éléments suivants aux propriétés de votre fonction. Assurez-vous de remplacer your-license-key-here par votre clé de licenceet otlp.nr-data.net:4317 par le point de terminaison New Relic OpenTelemetry pour votre région.

  yourFunctionHere:
    Type: AWS::Serverless::Function
    Properties:
      # ...
      Environment:
        Variables:
          # ...
          NEW_RELIC_LICENSE_KEY: your-license-key-here
          NEW_RELIC_OPENTELEMETRY_ENDPOINT: otlp.nr-data.net:4317
          OTEL_SERVICE_NAME: your-function-name-here

  Copier

  Important

  Remplacez your-license-key-here par votre New Relic clé de licenceet otlp.nr-data.net:4317 par le point de terminaison approprié pour votre région New Relic (voir la liste ci-dessus).

Configurer le Collector

Nous allons maintenant remplacer la OpenTelemetry Lambda Collector par défaut du configuration par une configuration qui exporte la télémétrie vers le OpenTelemetry point de terminaison New Relic . Pour ce faire, nous devons inclure un fichier de configuration collector.yaml avec notre fonction.

Créez un fichier collector.yaml dans le répertoire racine de votre fonction avec le contenu suivant :

receivers:
  otlp:
    protocols:
      grpc:
      http:

exporters:
  otlp:
    endpoint: ${env:NEW_RELIC_OPENTELEMETRY_ENDPOINT}
    headers:
      api-key: ${env:NEW_RELIC_LICENSE_KEY}

service:
  pipelines:
    traces:
      receivers: [otlp]
      exporters: [otlp]
    metrics:
      receivers: [otlp]
      exporters: [otlp]
    logs:
      receivers: [otlp]
      exporters: [otlp]

Regroupez ce fichier collector.yaml dans le répertoire racine du package zip de votre fonction.

Un exemple de configuration *.csproj pourrait ressembler à ceci :

<ItemGroup>
  <Content Include="collector.yaml">
    <CopyToOutputDirectory>Always</CopyToOutputDirectory>
  </Content>  
</ItemGroup>

Puis redéployez votre fonction.

1. Ouvrez votre fonction dans la console Lambda.
2. Choisissez Configuration puis Environment variables.
3. Sous Environment variables, choisissez Edit.
4. Choisissez Add environment variable.
5. Pour le Key définissez OPENTELEMETRY_COLLECTOR_CONFIG_FILE et définissez le Value sur /var/task/collector.yaml.
6. Choisissez ensuite Save.

Pour les modèles SAM et CloudFormation, ajoutez ceci aux propriétés de votre fonction :

yourFunctionHere:
  Type: AWS::Serverless::Function
  Properties:
    # ...
    Environment:
      Variables:
        # ...
        OPENTELEMETRY_COLLECTOR_CONFIG_FILE: /var/task/collector.yaml

Instrumenter Votre fonction

Ajoutez d’abord le SDK OpenTelemetry pour AWS Lambda, ainsi que le packageexportateur OTLP. Vous pouvez ajouter davantage de packages d'instrumentation OpenTelemetry , tels que OpenTelemetry.Instrumentation.AWS et OpenTelemetry.Instrumentation.Http, pour obtenir une visibilité supplémentaire sur le comportement de votre fonction.

$
dotnet add package OpenTelemetry.Instrumentation.AWSLambda
$
dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
$
dotnet add package OpenTelemetry.Instrumentation.AWS
$
dotnet add package OpenTelemetry.Instrumentation.Http

Ajoutez des appels à AddAWSLambdaConfigurations() et AddOtlpExporter() depuis TracerProvider dans le constructeur statique de votre fonction.

TracerProvider tracerProvider = Sdk.CreateTracerProviderBuilder()
    // add other instrumentations here
    .AddAWSLambdaConfigurations(options => options.DisableAwsXRayContextExtraction = true)
    .AddOtlpExporter()
    .Build();

Créez une fonction wrapper avec la même signature que la fonction de gestionnaire Lambda d’origine. Appelez l'API AWSLambdaWrapper.Trace() et transmettez TracerProvider, la fonction Lambda d'origine et ses entrées comme paramètres.

// new Lambda function handler passed in
public string TracingFunctionHandler(JObject input, ILambdaContext context) =>
    AWSLambdaWrapper.Trace(tracerProvider, OriginalFunctionHandler, input, context);

public string OriginalFunctionHandler(JObject input, ILambdaContext context) {
    return input?.ToString();
}

Si votre gestionnaire d'origine est une fonction asynchrone, utilisez l'API TraceAsync() au lieu de Trace().

public Task<APIGatewayProxyResponse> TracingFunctionHandler(APIGatewayProxyRequest request,
    ILambdaContext context)
    => AWSLambdaWrapper.TraceAsync(tracerProvider, OriginalFunctionHandler, request, context);

public async Task<APIGatewayProxyResponse> OriginalFunctionHandler(APIGatewayProxyRequest apigProxyEvent, ILambdaContext context)
{
    //your function here.
}

Par exemple, une fonction API Gateway de base Lambda ressemblerait à ceci :

using System;
using Amazon.Lambda.APIGatewayEvents;
using Amazon.Lambda.Core;
using OpenTelemetry;
using OpenTelemetry.Instrumentation.AWSLambda;
using OpenTelemetry.Trace;

namespace Example
{
    public class Function
    {
        public static TracerProvider tracerProvider;

        static Function()
        {
            tracerProvider = Sdk.CreateTracerProviderBuilder()
                .AddAWSLambdaConfigurations(options => options.DisableAwsXRayContextExtraction = true)
                .AddOtlpExporter()
                .Build();

            // use AwsSdkSample::AwsSdkSample.Function::TracingFunctionHandler as input Lambda handler instead
            public APIGatewayProxyResponse TracingFunctionHandler(APIGatewayProxyRequest request, ILambdaContext context)
            {
                return AWSLambdaWrapper.Trace(tracerProvider, FunctionHandler, request, context);
            }

            /// <summary>
            /// A simple function that takes a APIGatewayProxyRequest and returns a APIGatewayProxyResponse
            /// </summary>
            /// <param name="input"></param>
            /// <param name="context"></param>
            /// <returns></returns>
            public APIGatewayProxyResponse FunctionHandler(APIGatewayProxyRequest request, ILambdaContext context)
            {
                return new APIGatewayProxyResponse() {
                    StatusCode = 200,
                    Body = Environment.GetEnvironmentVariable("_X_AMZN_TRACE_ID")
                };
            }
        }
    }
}

Définissez ensuite la fonction wrapper comme gestionnaire de la fonction Lambda. Pour la classe ci-dessus, le gestionnaire serait function::Example.Function::TracingFunctionHandler.

Pour un exemple fonctionnel, y compris le tracing du SDK AWS, consultez cet exemple d'application.

Ce qui précède n'est qu'un exemple de base. Pour une instrumentation plus avancée, reportez-vous à la documentation du SDK OpenTelemetry .NET.

Affichez vos données dans l'interface utilisateur de New Relic

Tout d’abord, vous souhaiterez appeler votre fonction Lambda plusieurs fois pour commencer à générer de la télémétrie. De là, rendez-vous sur New Relic pour trouver votre trace, vos métriques et votre log.

Votre télémétrie n'apparaîtra pas sous New Relic Serverless. Au lieu de cela, vous trouverez vos données télémétriques sous les Nerdlets New Relic OpenTelemetry .