Traza tu función .NET Lambda con New Relic y OpenTelemetry

Instalar la capa

AWS publica una capa administrada que incluye el recolector OpenTelemetry Lambda.

Para instalarlo:

1. Abra su función en Lambda Console.

2. En Layers en la sección Designer , elija Add a layer.

3. En Specify an ARN, pegue uno de los ARN de capa para la arquitectura de su función de la lista siguiente. Reemplace {region}con su región de AWS, como us-east-1.

4. Elija 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 las plantillas SAM y CloudFormation, agregue lo siguiente a las propiedades de su función:

   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

   Copia

   Importante

   Consulte los ARN más recientes publicados por AWS para verificar que los ARN de capa anteriores estén actualizados.

Agregar variables de entorno de New Relic

Para enviar los datos de OpenTelemetry que esta capa recopila a New Relic, necesitamos configurar el recolector OpenTelemetry Lambda que está empaquetado con la capa para exportar la telemetría que recibe al extremo New Relic OpenTelemetry. Antes de hacer eso, primero debemos establecer algunas variables de entorno de las que dependerá.

1. Genera y copia una New Relic

   clave de licencia

   desde tu cuenta New Relic.

2. Abra su función en Lambda Console.

3. Elija

   Configuration

   y luego

   Environment variables

   .

4. En

   Environment variables

   , elija

   Edit

   .

5. Elija

   Add environment variable

   .

6. Para

   Key

   configúrelo en NEW_RELIC_LICENSE_KEY y establezca

   Value

   en el valor de la clave de licencia que generó en el paso 1. Luego elija

   Save

   .

7. Elija

   Add environment variable

   nuevamente.

8. Para

   Key

   configúrelo en NEW_RELIC_OPENTELEMETRY_ENDPOINT y configure

   Value

   en una de las siguientes opciones (depende de su región de New Relic). Luego elija

   Save

   .

9. Elija

   Add environment variable

   nuevamente.

10. Para

    Key

    configúrelo en OTEL_SERVICE_NAME y establezca

    Value

    en el nombre de su función. Luego elija

    Save

    .

• otlp.nr-data.net:4317: Si su cuenta New Relic está en la región de EE. UU.

• otlp.eu01.nr-data.net:4317: Si su cuenta New Relic está en la región de la UE

  Para las plantillas SAM y CloudFormation, agregue lo siguiente a las propiedades de su función. Asegúrese de reemplazar your-license-key-here con su clave de licenciay otlp.nr-data.net:4317 con el extremo New Relic OpenTelemetry para su región.

  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

  Copia

  Importante

  Reemplace your-license-key-here con su New Relic clave de licenciay otlp.nr-data.net:4317 con el extremo apropiado para su región de New Relic (consulte la lista anterior).

Configurar el recolector

Ahora anularemos la configuración predeterminada del recolector OpenTelemetry Lambda con una que exporte telemetría al extremo New Relic OpenTelemetry. Para hacer esto debemos incluir un archivo de configuración collector.yaml con nuestra función.

Cree un archivo collector.yaml en el directorio raíz de su función con el siguiente contenido:

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]

Empaquete este archivo collector.yaml en el directorio raíz del paquete zip de su función.

Un ejemplo de configuración *.csproj podría verse así:

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

Luego vuelve a desplegar tu función.

1. Abra su función en Lambda Console.

2. Elija

   Configuration

   y luego

   Environment variables

   .

3. En

   Environment variables

   , elija

   Edit

   .

4. Elija

   Add environment variable

   .

5. Para

   Key

   establezca OPENTELEMETRY_COLLECTOR_CONFIG_FILE y establezca

   Value

   en /var/task/collector.yaml.

6. Luego elija

   Save

   .

Para las plantillas SAM y CloudFormation, agregue esto a las propiedades de su función:

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

Instrumentado Tu Función

Primero agregue el SDK de OpenTelemetry para AWS Lambda, así como el paquete exportador OTLP. Puede agregar más paquetes de instrumentación de OpenTelemetry, como OpenTelemetry.instrumentación.AWS y OpenTelemetry.instrumentación.Http, para obtener visibilidad adicional del comportamiento de su función.

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

Agregue llamadas a AddAWSLambdaConfigurations() y AddOtlpExporter() desde TracerProvider en el constructor estático de su función.

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

Cree una función contenedora con la misma firma que la función del controlador Lambda original. Llame a la API AWSLambdaWrapper.Trace() y pase TracerProvider, la función Lambda original y sus 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();
}

Si su controlador original es una función asíncrona, utilice la API TraceAsync() en lugar 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 ejemplo, una función Lambda básica de API Gateway se vería así:

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

Luego configure la función contenedora como controlador de la función Lambda. Para la clase anterior, el controlador sería function::Example.Function::TracingFunctionHandler.

Para ver un ejemplo práctico, incluido el seguimiento del SDK de AWS, consulte esta aplicación de muestra.

Lo anterior es solo un ejemplo básico; para instrumentación más avanzada, consulte la documentación de OpenTelemetry .NET SDK.

Vea sus datos en la UI de New Relic

Primero querrás invocar tu función Lambda varias veces para comenzar a generar telemetría. Desde allí, dirígete a New Relic para encontrar tu traza, métrica y registro.

Su telemetría no aparecerá en New Relic Serverless. En su lugar, encontrará sus telemetry data en New Relic OpenTelemetry Nerdlets.