Trace sua função .NET do Lambda com New Relic e OpenTelemetry

Instale a camada

A AWS publica uma camada gerenciada que inclui o coletor OpenTelemetry Lambda.

Para instalá-lo:

1. Abra sua função no Console do Lambda.

2. Em Layers na seção Designer , escolha Add a layer.

3. Em Specify an ARN, cole um dos ARNs de camada para a arquitetura da sua função na lista abaixo. Substitua {region}pela sua região da AWS, como us-east-1.

4. Escolha 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

   Para modelos SAM e CloudFormation, adicione o seguinte às propriedades da sua função:

   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

   Copiar

   Importante

   Consulte os ARNs mais recentes publicados pela AWS para verificar se os ARNs da camada acima estão atualizados.

Adicionar variáveis de ambiente do New Relic

Para enviar os dados OpenTelemetry que esta camada coleta para o New Relic, precisamos configurar o coletor OpenTelemetry Lambda que é empacotado com a camada para exportar a telemetria que recebe para o endpointOpenTelemetry do New Relic. Antes de fazermos isso, primeiro precisamos definir algumas variáveis de ambiente das quais dependerá.

1. Gere e copie uma New Relic chave de licençada sua conta New Relic.
2. Abra sua função no Lambda Console.
3. Escolha Configuration e depois Environment variables.
4. Em Environment variables, escolha Edit.
5. Escolha Add environment variable.
6. Para Key defina-o como NEW_RELIC_LICENSE_KEY e defina Value como o valor da chave de licença gerada na etapa 1. Em seguida, escolha Save.
7. Escolha Add environment variable novamente.
8. Para Key defina-o como NEW_RELIC_OPENTELEMETRY_ENDPOINT e defina Value como uma das opções abaixo (depende da sua região do New Relic). Em seguida, escolha Save.
9. Escolha Add environment variable novamente.
10. Para Key defina-o como OTEL_SERVICE_NAME e defina Value como o nome da sua função. Em seguida, escolha Save.

• otlp.nr-data.net:4317: Se sua conta New Relic estiver na região dos EUA

• otlp.eu01.nr-data.net:4317: Se a sua conta New Relic estiver na região da UE

  Para modelos SAM e CloudFormation, adicione o seguinte às propriedades da sua função. Certifique-se de substituir your-license-key-here por seu chave de licençae otlp.nr-data.net:4317 pelo endpoint New Relic OpenTelemetry para sua região.

  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

  Copiar

  Importante

  Substitua your-license-key-here pelo seu New Relic chave de licençae otlp.nr-data.net:4317 pelo endpoint apropriado para sua região do New Relic (veja a lista acima).

Configurar o coletor

Agora substituiremos a configuração padrão do coletor OpenTelemetry Lambda por uma que exporte a telemetria para o endpoint New Relic OpenTelemetry. Para fazer isso, devemos incluir um arquivo de configuração collector.yaml com nossa função.

Crie um arquivo collector.yaml no diretório raiz da sua função com o seguinte conteúdo:

receivers:
  otlp:
    protocols:
      grpc:
      http:

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

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

Agrupe esse arquivo collector.yaml no diretório raiz do pacote zip da sua função.

Um exemplo de configuração *.csproj pode ser assim:

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

Então reimplante sua função.

1. Abra sua função no Console do Lambda.
2. Escolha Configuration e depois Environment variables.
3. Em Environment variables, escolha Edit.
4. Escolha Add environment variable.
5. Para Key defina OPENTELEMETRY_COLLECTOR_CONFIG_FILE e defina Value como /var/task/collector.yaml.
6. Em seguida, escolha Save.

Para modelos SAM e CloudFormation, adicione isto às propriedades da sua função:

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

Instrumento Sua Função

Primeiro adicione o OpenTelemetry SDK para AWS Lambda, bem como o pacote de exportação OTLP. Você pode adicionar mais pacotes de instrumentação OpenTelemetry, como OpenTelemetry.instrumentação.AWS e OpenTelemetry.instrumentação.Http, para obter visibilidade adicional sobre o comportamento da sua função.

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

Adicione chamadas para AddAWSLambdaConfigurations() e AddOtlpExporter() de TracerProvider no construtor estático da sua função.

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

Crie uma função wrapper com a mesma assinatura da função manipuladora do Lambda original. Chame a API AWSLambdaWrapper.Trace() e passe TracerProvider, a função original do Lambda, e suas entradas como parâmetro.

// 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();
}

Se o seu gerenciador original for uma função assíncrona, use a API TraceAsync() em vez 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.
}

Por exemplo, uma função básica do API Gateway do Lambda ficaria assim:

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")
                };
            }
        }
    }
}

Em seguida, defina a função wrapper como o manipulador da função do Lambda. Para a classe acima, o manipulador seria function::Example.Function::TracingFunctionHandler.

Para obter um exemplo prático, incluindo o rastreamento do AWS SDK, consulte este aplicativo de exemplo.

O exemplo acima é apenas um exemplo básico. Para instrumentação mais avançada, consulte a documentação do OpenTelemetry .NET SDK.

Visualize seus dados na interface do New Relic

Primeiro você vai querer invocar sua função do Lambda algumas vezes para começar a gerar telemetria. A partir daí, vá para New Relic para encontrar seu trace, métrica e log.

Sua telemetria não aparecerá no New Relic Serverless. Em vez disso, você encontrará seus dados de telemetria nos New Relic OpenTelemetry Nerdlets.