

# Registro y supervisión de las funciones de Lambda de C\$1
<a name="csharp-logging"></a>

AWS Lambda supervisa de forma automática funciones de Lambda y envía entradas de registros a Amazon CloudWatch. Su función de Lambda viene con un grupo de registros de Registros de CloudWatch y con un flujo de registro para cada instancia de su función. El entorno de tiempo de ejecución de Lambda envía detalles sobre cada invocación y otros resultados del código de su función al flujo de registro. Para obtener más información acerca de Registros de CloudWatch, consulte [Envío de registros de funciones de Lambda a Registros de CloudWatch](monitoring-cloudwatchlogs.md).

**Topics**
+ [Crear una función que devuelve registros](#csharp-logging-output)
+ [Uso de los controles de registro avanzados de Lambda con .NET](#csharp-logging-advanced)
+ [Herramientas y bibliotecas de registro adicionales](#csharp-tools-libraries)
+ [Uso de Powertools para AWS Lambda (.NET) y AWS SAM para el registro estructurado](#dotnet-logging-sam)
+ [Visualización de los registros en la consola de Lambda](#csharp-logging-console)
+ [Visualización de los registros de en la consola de CloudWatch](#csharp-logging-cwconsole)
+ [Visualización de los registros mediante la AWS Command Line Interface (AWS CLI)](#csharp-logging-cli)
+ [Eliminación de registros](#csharp-logging-delete)

## Crear una función que devuelve registros
<a name="csharp-logging-output"></a>

Para generar registros desde el código de su función, puede utilizar el [ILambdaLogger](https://github.com/aws/aws-lambda-dotnet/blob/master/Libraries/src/Amazon.Lambda.Core/ILambdaLogger.cs) en el objeto de contexto, los métodos de la [Clase de consola](https://docs.microsoft.com/en-us/dotnet/api/system.console), o cualquier biblioteca de registro que escriba en `stdout` o `stderr`.

El tiempo de ejecución de .NET registra las líneas `START`, `END` y `REPORT` de cada invocación. La línea del informe proporciona los siguientes detalles.

**Campos de datos de línea REPORT**
+ **RequestId**: el ID de solicitud único para la invocación.
+ **Duración**: la cantidad de tiempo que el método de controlador de función pasó procesando el evento.
+ **Duración facturada**: la cantidad de tiempo facturado por la invocación.
+ **Tamaño de memoria**: la cantidad de memoria asignada a la función.
+ **Máximo de memoria usada**: la cantidad de memoria utilizada por la función. Cuando las invocaciones comparten un entorno de ejecución, Lambda informa de la memoria máxima utilizada en todas las invocaciones. Este comportamiento puede dar como resultado un valor notificado superior al esperado.
+ **Duración de inicio**: para la primera solicitud servida, la cantidad de tiempo que tardó el tiempo de ejecución en cargar la función y ejecutar código fuera del método del controlador.
+ **TraceId de XRAY**: para las solicitudes rastreadas, el [ID de seguimientode AWS X-Ray](services-xray.md).
+ **SegmentId**: para solicitudes rastreadas, el ID del segmento de X-Ray.
+ **Muestras**: para solicitudes rastreadas, el resultado del muestreo.

## Uso de los controles de registro avanzados de Lambda con .NET
<a name="csharp-logging-advanced"></a>

Para tener más control sobre cómo se registran, procesan y consumen los registros de las funciones, puede configurar las siguientes opciones de registro para los tiempos de ejecución de .NET admitidos:
+ **Formato de registro**: seleccione entre texto sin formato y el formato JSON estructurado para los registros de su función
+ **Nivel de registro**: para los registros en formato JSON, elija el nivel de detalle de los registros que Lambda envía a CloudWatch, como ERROR, DEBUG o INFO
+ **Grupo de registro**: elija el grupo de registro de CloudWatch al que su función envía los registros

Para obtener más información sobre estas opciones de registro e instrucciones sobre cómo configurar la función para utilizarlas, consulte [Configuración de controles de registro avanzados para las funciones de Lambda](monitoring-logs.md#monitoring-cloudwatchlogs-advanced).

Para usar las opciones de formato y nivel de registro con las funciones de Lambda de .NET, consulte las instrucciones de las siguientes secciones.

### Uso del formato de registro JSON estructurado con .NET
<a name="csharp-logging-advanced-JSON"></a>

Si selecciona JSON para el formato de registro de la función, Lambda enviará los registros de salida mediante [ILambdaLogger](https://github.com/aws/aws-lambda-dotnet/blob/master/Libraries/src/Amazon.Lambda.Core/ILambdaLogger.cs) como JSON estructurado. Cada objeto de registro JSON contiene, por lo menos, cinco pares clave-valor con las siguientes claves:
+ `"timestamp"`: la hora en que se generó el mensaje de registro
+ `"level"`: el nivel de registro asignado al mensaje
+ `"requestId"`: el ID de solicitud único para la invocación de la función
+ `"traceId"`: la variable de entorno `_X_AMZN_TRACE_ID`
+ `"message"`: el contenido del mensaje de registro

La instancia `ILambdaLogger` puede agregar pares clave-valor adicionales, por ejemplo, al registrar excepciones. También puede proporcionar sus propios parámetros adicionales, tal y como se describe en la sección [Parámetros de registro proporcionados por el cliente](#csharp-logging-advanced-JSON-user-supplied).

**nota**  
Si su código ya usa otra biblioteca de registro para generar registros con formato JSON, asegúrese de que el formato de registro de la función esté establecido en texto sin formato. Si se establece el formato de registro en JSON, los resultados del registro se codificarán doblemente.

En el siguiente ejemplo de comando de registro, se muestra cómo escribir un mensaje de registro con el nivel `INFO`.

**Example Código de registro en .NET**  

```
context.Logger.LogInformation("Fetching cart from database");
```

También puede utilizar un método de registro genérico que tome el nivel de registro como argumento, como se muestra en el siguiente ejemplo.

```
context.Logger.Log(LogLevel.Information, "Fetching cart from database");
```

La salida del registro generada por estos fragmentos de código de ejemplo se capturaría en Registros de CloudWatch de la siguiente manera:

**Example Entrada de registro JSON**  

```
{
    "timestamp": "2025-09-07T01:30:06.977Z",
    "level": "Information",
    "requestId": "8f711428-7e55-46f9-ae88-2a65d4f85fc5",
    "traceId": "1-6408af34-50f56f5b5677a7d763973804",
    "message": "Fetching cart from database"
}
```

**nota**  
Si configura el formato de registro de la función para que utilice texto sin formato en lugar de JSON, el nivel de registro capturado en el mensaje sigue la convención de Microsoft de usar una etiqueta de cuatro caracteres. Por ejemplo, un nivel de registro de `Debug` se representa en el mensaje como `dbug`.  
Al configurar la función para utilizar registros con formato JSON, el nivel de registro capturado en el registro utiliza la etiqueta completa, como se muestra en el registro de registro JSON de ejemplo.

Si no asigna un nivel a la salida del registro, Lambda asignará el nivel INFO automáticamente.

#### Registro de excepciones en JSON
<a name="csharp-logging-advanced-JSON-exceptions"></a>

Si utiliza el registro JSON estructurado con `ILambdaLogger`, puede registrar las excepciones en su código, como se muestra en el siguiente ejemplo.

**Example uso del registro de excepciones**  

```
try
{
    connection.ExecuteQuery(query);
}
catch(Exception e)
{
    context.Logger.LogWarning(e, "Error executing query");
}
```

El resultado en formato de registro de este código se muestra en el ejemplo siguiente de JSON. Tenga en cuenta que la propiedad `message` de JSON se rellena con el argumento message proporcionado en la llamada `LogWarning`, mientras que la propiedad `errorMessage` proviene de la propiedad `Message` de la propia excepción.

**Example Entrada de registro JSON**  

```
{
    "timestamp": "2025-09-07T01:30:06.977Z",
    "level": "Warning",
    "requestId": "8f711428-7e55-46f9-ae88-2a65d4f85fc5",
    "traceId": "1-6408af34-50f56f5b5677a7d763973804",
    "message": "Error executing query",
    "errorType": "System.Data.SqlClient.SqlException",
    "errorMessage": "Connection closed",
    "stackTrace": ["<call exception.StackTrace>"]
}
```

Si el formato de registro de la función está establecido en JSON, Lambda también genera mensajes de registro con formato JSON cuando el código arroja una excepción no detectada. En el siguiente ejemplo, el fragmento de código y el mensaje de registro muestran cómo se registran las excepciones no detectadas.

**Example código de excepción**  

```
throw new ApplicationException("Invalid data");
```

**Example Entrada de registro JSON**  

```
{
    "timestamp": "2025-09-07T01:30:06.977Z",
    "level": "Error",
    "requestId": "8f711428-7e55-46f9-ae88-2a65d4f85fc5",
    "traceId": "1-6408af34-50f56f5b5677a7d763973804",
    "message": "Invalid data",
    "errorType": "System.ApplicationException",
    "errorMessage": "Invalid data",
    "stackTrace": ["<call exception.StackTrace>"]
}
```

#### Parámetros de registro proporcionados por el cliente
<a name="csharp-logging-advanced-JSON-user-supplied"></a>

Con los mensajes de registro con formato JSON, puede proporcionar parámetros de registro adicionales e incluirlos en el registro `message`. En el siguiente ejemplo de fragmento de código, se muestra un comando para agregar dos parámetros proporcionados por el usuario denominados `retryAttempt` y `uri`. En el ejemplo, el valor de estos parámetros proviene de los argumentos `retryAttempt` y `uriDestination` transferidos al comando logging.

**Example Comando de registro JSON con parámetros adicionales**  

```
context.Logger.LogInformation("Starting retry {retryAttempt} to make GET request to {uri}", retryAttempt, uriDestination);
```

El resultado del mensaje de registro de este comando se muestra en el ejemplo siguiente de JSON.

**Example Entrada de registro JSON**  

```
{
    "timestamp": "2025-09-07T01:30:06.977Z",
    "level": "Information",
    "requestId": "8f711428-7e55-46f9-ae88-2a65d4f85fc5",
    "traceId": "1-6408af34-50f56f5b5677a7d763973804",
    "message": "Starting retry 1 to make GET request to http://example.com/",
    "retryAttempt": 1,
    "uri": "http://example.com/"
}
```

**sugerencia**  
También puede usar propiedades posicionales en lugar de nombres al especificar parámetros adicionales. Por ejemplo, el comando de registro en el ejemplo anterior también podría escribirse de la siguiente manera:  

```
context.Logger.LogInformation("Starting retry {0} to make GET request to {1}", retryAttempt, uriDestination);
```

Tenga en cuenta que cuando suministra parámetros adicionales de registro, Lambda los captura como propiedades de nivel superior en el registro de registros en JSON. Este enfoque difiere de algunas bibliotecas populares de registro en .NET, como `Serilog`, que captura parámetros adicionales en un objeto secundario separado.

Si el argumento que proporciona para un parámetro adicional es un objeto complejo, Lambda utilizará el método `ToString()` de forma predeterminada para proporcionar el valor. Para indicar que un argumento debe estar serializado en JSON, utilice el prefijo `@` como se muestra en el siguiente fragmento de código. En este ejemplo, `User` es un objeto con propiedades `FirstName` y `LastName`.

**Example Comando de registro JSON con objeto serializado JSON**  

```
context.Logger.LogInformation("User {@user} logged in", User);
```

El resultado del mensaje de registro de este comando se muestra en el ejemplo siguiente de JSON.

**Example Entrada de registro JSON**  

```
{
    "timestamp": "2025-09-07T01:30:06.977Z",
    "level": "Information",
    "requestId": "8f711428-7e55-46f9-ae88-2a65d4f85fc5",
    "traceId": "1-6408af34-50f56f5b5677a7d763973804",
    "message": "User {@user} logged in",
    "user": 
    {
        "FirstName": "John",
        "LastName": "Doe"
    }
}
```

Si el argumento de un parámetro adicional es una matriz o implementa `IList` o `IDictionary`, Lambda agrega el argumento al mensaje de registro JSON como una matriz, como se muestra en el siguiente ejemplo de registro JSON. En este ejemplo, `{users}` toma un argumento `IList` que contiene instancias de la propiedad `User` con el mismo formato que en el ejemplo anterior. Lambda convierte a `IList` en una matriz y cada valor se crea mediante el método `ToString`.

**Example Registro de registro JSON con un argumento `IList`**  

```
{
    "timestamp": "2025-09-07T01:30:06.977Z",
    "level": "Information",
    "requestId": "8f711428-7e55-46f9-ae88-2a65d4f85fc5",
    "traceId": "1-6408af34-50f56f5b5677a7d763973804",
    "message": "{users} have joined the group",
    "users": 
    [
        "Rosalez, Alejandro",
        "Stiles, John"       
    ] 
}
```

También puede serializar la lista en JSON mediante el prefijo `@` del comando de registro. En el siguiente ejemplo de registro JSON, la propiedad `users` está serializada en JSON.

**Example Registro de registros JSON con un argumento `IList` serializado JSON**  

```
{
    "timestamp": "2025-09-07T01:30:06.977Z",
    "level": "Information",
    "requestId": "8f711428-7e55-46f9-ae88-2a65d4f85fc5",
    "traceId": "1-6408af34-50f56f5b5677a7d763973804",
    "message": "{@users} have joined the group",
    "users": 
    [
        {
            "FirstName": "Alejandro",
            "LastName": "Rosalez"
        },
        {
            "FirstName": "John",
            "LastName": "Stiles"
        }        
    ] 
}
```

### Uso del filtrado de registros con .NET
<a name="csharp-logging-advanced-levels"></a>

Al configurar el filtrado de registros, puede elegir enviar solo los registros de un nivel de detalle específico o inferior a los Registros de CloudWatch. Para obtener información sobre cómo configurar el filtrado a nivel de registro para su función, consulte [Filtrado a nivel de registro](monitoring-cloudwatchlogs-log-level.md).

Para que AWS Lambda filtre los mensajes de registro por nivel de registro, puede usar registros con formato JSON o usar los métodos. NET `Console` para generar mensajes de registro. Para crear registros con formato JSON, [configure el tipo de registro de su función en JSON](monitoring-cloudwatchlogs-logformat.md#monitoring-cloudwatchlogs-set-format) y use la instancia `ILambdaLogger`.

Con los registros en formato JSON, Lambda filtra sus salidas de registro mediante el par clave-valor “level” en el objeto JSON descrito en [Uso del formato de registro JSON estructurado con .NET](#csharp-logging-advanced-JSON).

Si utiliza los métodos .NET `Console` para escribir mensajes en los Registros de CloudWatch, Lambda aplicará los siguientes niveles de registro a los mensajes:
+ **Método Console.WriteLine**: Lambda aplica un nivel de registro de `INFO`
+ **Método Console.Error**: Lambda aplica un nivel de registro de `ERROR`

Cuando configura la función para que utilice el filtrado a nivel de registro, debe seleccionar una de las siguientes opciones para el nivel de registros que desea que Lambda envíe a los Registros de CloudWatch. Observe la asignación de los niveles de registro utilizados por Lambda con los niveles estándar de Microsoft utilizados por .NET `ILambdaLogger`.


| Nivel de registro de Lambda | Nivel de Microsoft equivalente | Uso estándar | 
| --- | --- | --- | 
| TRACE (más detallado) | Rastreo | La información más detallada que se utiliza para rastrear la ruta de ejecución del código | 
| DEBUG | Debug | Información detallada para la depuración del sistema | 
| INFO | Información | Mensajes que registran el funcionamiento normal de su función | 
| WARN | Advertencia | Mensajes sobre posibles errores que pueden provocar un comportamiento inesperado si no se abordan | 
| ERROR | Error | Mensajes sobre problemas que impiden que el código funcione según lo esperado | 
| FATAL (menos detallado) | Critico | Mensajes sobre errores graves que hacen que la aplicación deje de funcionar | 

Lambda envía los registros del nivel de detalle seleccionado e inferior a CloudWatch. Por ejemplo, si configura un nivel de registro de WARN, Lambda enviará los registros correspondientes a los niveles WARN, ERROR y FATAL.

## Herramientas y bibliotecas de registro adicionales
<a name="csharp-tools-libraries"></a>

[Powertools para AWS Lambda (.NET)](https://docs.aws.amazon.com/powertools/dotnet/) es un kit de herramientas para desarrolladores destinado a implementar prácticas recomendadas sin servidor y aumentar la velocidad de los desarrolladores. La [utilidad de registro](https://docs.aws.amazon.com/powertools/dotnet/core/logging/) proporciona un logger optimizado para Lambda que incluye información adicional sobre el contexto de la función en todas las funciones con un resultado estructurado como JSON. Utilice esta utilidad para hacer lo siguiente:
+ Capturar campos clave del contexto de Lambda, arranque en frío y resultados de registro de estructuras como JSON
+ Registrar los eventos de invocación de Lambda cuando se le indique (desactivado de forma predeterminada)
+ Imprimir todos los registros solo para un porcentaje de las invocaciones mediante el muestreo de registros (desactivado de forma predeterminada)
+ Agregar claves adicionales al registro estructurado en cualquier momento
+ Utilizar un formateador de registros personalizado (traiga su propio formateador) para generar registros en una estructura compatible con el RFC de registro de su organización

## Uso de Powertools para AWS Lambda (.NET) y AWS SAM para el registro estructurado
<a name="dotnet-logging-sam"></a>

Siga los pasos que figuran a continuación para descargar, crear e implementar una aplicación de muestra “Hola, mundo” de C\$1 con módulos de [Powertools para AWS Lambda (.NET)](https://docs.powertools.aws.dev/lambda-dotnet) integrados mediante AWS SAM. Esta aplicación implementa un backend de API básico y utiliza Powertools para emitir registros, métricas y seguimiento. Consta de un punto de conexión de Amazon API Gateway y una función de Lambda. Cuando se envía una solicitud GET al punto de conexión de API Gateway, la función de Lambda se invoca, envía registros y métricas a CloudWatch mediante Embedded Metric Format y envía seguimiento a AWS X-Ray. La función devuelve el mensaje `hello world`.

**Requisitos previos**

Para completar los pasos de esta sección, debe disponer de lo siguiente:
+ .NET 8
+ [AWS CLI versión 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [AWS SAM Versión 1.75 o posterior de la CLI de](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). Si tiene una versión anterior de la CLI de AWS SAM, consulte [Actualización de la CLI de AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/manage-sam-cli-versions.html#manage-sam-cli-versions-upgrade).

**Implementar una aplicación de ejemplo de AWS SAM**

1. Inicialice la aplicación utilizando la plantilla de TypeScript de tipo Hola Mundo.

   ```
   sam init --app-template hello-world-powertools-dotnet --name sam-app --package-type Zip --runtime dotnet6 --no-tracing
   ```

1. Compile la aplicación.

   ```
   cd sam-app && sam build
   ```

1. Implemente la aplicación.

   ```
   sam deploy --guided
   ```

1. Siga las indicaciones que aparecen en pantalla. Para aceptar las opciones predeterminadas proporcionadas en la experiencia interactiva, oprima `Enter`.
**nota**  
En **HelloWorldFunction es posible que no tenga definida la autorización, ¿está bien?**, asegúrese de ingresar `y`.

1. Obtenga la URL de la aplicación implementada:

   ```
   aws cloudformation describe-stacks --stack-name sam-app --query 'Stacks[0].Outputs[?OutputKey==`HelloWorldApi`].OutputValue' --output text
   ```

1. Invoque el punto de conexión de la API:

   ```
   curl -X GET <URL_FROM_PREVIOUS_STEP>
   ```

   Si se realiza de forma correcta, verá el siguiente resultado:

   ```
   {"message":"hello world"}
   ```

1. Para obtener los registros de la función, ejecute [sam logs](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-logs.html). Para obtener más información, consulte [Uso de registros](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-logging.html) en la *Guía para desarrolladores de AWS Serverless Application Model*.

   ```
   sam logs --stack-name sam-app
   ```

   El resultado del registro tendrá este aspecto:

   ```
   2025/02/20/[$LATEST]4eaf8445ba7a4a93b999cb17fbfbecd8 2025-09-20T14:15:27.988000 INIT_START Runtime Version: dotnet:6.v13        Runtime Version ARN: arn:aws:lambda:ap-southeast-2::runtime:699f346a05dae24c58c45790bc4089f252bf17dae3997e79b17d939a288aa1ec
   2025/02/20/[$LATEST]4eaf8445ba7a4a93b999cb17fbfbecd8 2025-09-20T14:15:28.229000 START RequestId: bed25b38-d012-42e7-ba28-f272535fb80e Version: $LATEST
   2025/02/20/[$LATEST]4eaf8445ba7a4a93b999cb17fbfbecd8 2025-09-20T14:15:29.259000 2025-09-20T14:15:29.201Z        bed25b38-d012-42e7-ba28-f272535fb80e    info   {"_aws":{"Timestamp":1676902528962,"CloudWatchMetrics":[{"Namespace":"sam-app-logging","Metrics":[{"Name":"ColdStart","Unit":"Count"}],"Dimensions":[["FunctionName"],["Service"]]}]},"FunctionName":"sam-app-HelloWorldFunction-haKIoVeose2p","Service":"PowertoolsHelloWorld","ColdStart":1}
   2025/02/20/[$LATEST]4eaf8445ba7a4a93b999cb17fbfbecd8 2025-09-20T14:15:30.479000 2025-09-20T14:15:30.479Z        bed25b38-d012-42e7-ba28-f272535fb80e    info   {"ColdStart":true,"XrayTraceId":"1-63f3807f-5dbcb9910c96f50742707542","CorrelationId":"d3d4de7f-4ccc-411a-a549-4d67b2fdc015","FunctionName":"sam-app-HelloWorldFunction-haKIoVeose2p","FunctionVersion":"$LATEST","FunctionMemorySize":256,"FunctionArn":"arn:aws:lambda:ap-southeast-2:123456789012:function:sam-app-HelloWorldFunction-haKIoVeose2p","FunctionRequestId":"bed25b38-d012-42e7-ba28-f272535fb80e","Timestamp":"2025-09-20T14:15:30.4602970Z","Level":"Information","Service":"PowertoolsHelloWorld","Name":"AWS.Lambda.Powertools.Logging.Logger","Message":"Hello world API - HTTP 200"}
   2025/02/20/[$LATEST]4eaf8445ba7a4a93b999cb17fbfbecd8 2025-09-20T14:15:30.599000 2025-09-20T14:15:30.599Z        bed25b38-d012-42e7-ba28-f272535fb80e    info   {"_aws":{"Timestamp":1676902528922,"CloudWatchMetrics":[{"Namespace":"sam-app-logging","Metrics":[{"Name":"ApiRequestCount","Unit":"Count"}],"Dimensions":[["Service"]]}]},"Service":"PowertoolsHelloWorld","ApiRequestCount":1}
   2025/02/20/[$LATEST]4eaf8445ba7a4a93b999cb17fbfbecd8 2025-09-20T14:15:30.680000 END RequestId: bed25b38-d012-42e7-ba28-f272535fb80e
   2025/02/20/[$LATEST]4eaf8445ba7a4a93b999cb17fbfbecd8 2025-09-20T14:15:30.680000 REPORT RequestId: bed25b38-d012-42e7-ba28-f272535fb80e  Duration: 2450.99 ms   Billed Duration: 2692 ms Memory Size: 256 MB     Max Memory Used: 74 MB  Init Duration: 240.05 ms
   XRAY TraceId: 1-63f3807f-5dbcb9910c96f50742707542       SegmentId: 16b362cd5f52cba0
   ```

1. Se trata de un punto de conexión de API pública al que se puede acceder a través de Internet. Se recomienda eliminar el punto de conexión después de las pruebas.

   ```
   sam delete
   ```

### Administración de retención de registros
<a name="csharp-log-retention"></a>

Los grupos de registro no se eliminan automáticamente cuando se elimina una función. Para evitar almacenar registros de forma indefinida, elimine el grupo de registros o configure un periodo de retención después del cual CloudWatch los eliminará de forma automática. Para configurar la retención de registros, agregue lo siguiente a la plantilla de AWS SAM:

```
Resources:
  HelloWorldFunction:
    Type: AWS::Serverless::Function
    Properties:
      # Omitting other properties

  LogGroup:
    Type: AWS::Logs::LogGroup
    Properties:
      LogGroupName: !Sub "/aws/lambda/${HelloWorldFunction}"
      RetentionInDays: 7
```

## Visualización de los registros en la consola de Lambda
<a name="csharp-logging-console"></a>

Puede utilizar la consola de Lambda para ver la salida del registro después de invocar una función de Lambda.

Si su código se puede probar desde el editor de **código** integrado, encontrará los registros en los **resultados de ejecución**. Cuando utilice la característica de prueba de la consola para invocar una función, encontrará la **Salida de registro** en la sección de **Detalles**.

## Visualización de los registros de en la consola de CloudWatch
<a name="csharp-logging-cwconsole"></a>

Puede utilizar la consola Amazon CloudWatch para ver los registros de todas las invocaciones de funciones de Lambda.

**Visualización de los registros en la consola CloudWatch**

1. En la consola de CloudWatch, abra la [página de grupos de registro](https://console.aws.amazon.com/cloudwatch/home?#logs:).

1. Seleccione el grupo de registros para su función (**/aws/lambda/*your-function-name***).

1. Elija una secuencia de registro.

Cada flujo de registro se corresponde con una [instancia de su función](lambda-runtime-environment.md). Aparece un flujo de registro cuando actualiza la función de Lambda y cuando se crean instancias adicionales para gestionar invocaciones simultáneas. Para encontrar registros para una invocación específica, le recomendamos que interfiera su función con AWS X-Ray. X-Ray registra los detalles sobre la solicitud y el flujo de registro en el seguimiento.

## Visualización de los registros mediante la AWS Command Line Interface (AWS CLI)
<a name="csharp-logging-cli"></a>

La AWS CLI es una herramienta de código abierto que lo habilita para interactuar con los servicios de AWS mediante el uso de comandos en el intérprete de comandos de la línea de comandos. Para completar los pasos de esta sección, debe disponer de la [versión 2 de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).

Puede utilizar la [CLI de AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) para recuperar registros de una invocación mediante la opción de comando `--log-type`. La respuesta contiene un campo `LogResult` que contiene hasta 4 KB de registros con codificación base64 a partir de la invocación.

**Example recuperar un ID de registro**  
En el ejemplo siguiente se muestra cómo recuperar un *ID de registro* del campo `LogResult` para una función denominada `my-function`.  

```
aws lambda invoke --function-name my-function out --log-type Tail
```
Debería ver los siguientes datos de salida:  

```
{
    "StatusCode": 200,
    "LogResult": "U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
    "ExecutedVersion": "$LATEST"
}
```

**Example decodificar los registros**  
En el mismo símbolo del sistema, utilice la utilidad `base64` para decodificar los registros. En el ejemplo siguiente se muestra cómo recuperar registros codificados en base64 para `my-function`.  

```
aws lambda invoke --function-name my-function out --log-type Tail \
--query 'LogResult' --output text --cli-binary-format raw-in-base64-out | base64 --decode
```
La opción **cli-binary-format** es obligatoria si va a utilizar la versión 2 de la AWS CLI. Para que esta sea la configuración predeterminada, ejecute `aws configure set cli-binary-format raw-in-base64-out`. Para obtener más información, consulte [Opciones de la línea de comandos globales compatibles con AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) en la *Guía del usuario de la AWS Command Line Interface versión 2*.  
Debería ver los siguientes datos de salida:  

```
START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST
"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8  Duration: 79.67 ms      Billed Duration: 80 ms         Memory Size: 128 MB     Max Memory Used: 73 MB
```
La utilidad `base64` está disponible en Linux, macOS y [Ubuntu en Windows](https://docs.microsoft.com/en-us/windows/wsl/install-win10). Es posible que los usuarios de macOS necesiten usar `base64 -D`.

**Example get-logs.sh script**  
En el mismo símbolo del sistema, utilice el siguiente script para descargar los últimos cinco eventos de registro. El script utiliza `sed` para eliminar las comillas del archivo de salida y permanece inactivo durante 15 segundos para dar tiempo a que los registros estén disponibles. La salida incluye la respuesta de Lambda y la salida del comando `get-log-events`.   
Copie el contenido de la siguiente muestra de código y guárdelo en su directorio de proyecto Lambda como `get-logs.sh`.  
La opción **cli-binary-format** es obligatoria si va a utilizar la versión 2 de la AWS CLI. Para que esta sea la configuración predeterminada, ejecute `aws configure set cli-binary-format raw-in-base64-out`. Para obtener más información, consulte [Opciones de la línea de comandos globales compatibles con AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-options.html#cli-configure-options-list) en la *Guía del usuario de la AWS Command Line Interface versión 2*.  

```
#!/bin/bash
aws lambda invoke --function-name my-function --cli-binary-format raw-in-base64-out --payload '{"key": "value"}' out
sed -i'' -e 's/"//g' out
sleep 15
aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name stream1 --limit 5
```

**Example macOS y Linux (solamente)**  
En el mismo símbolo del sistema, es posible que los usuarios de macOS y Linux necesiten ejecutar el siguiente comando para asegurarse de que el script es ejecutable.  

```
chmod -R 755 get-logs.sh
```

**Example recuperar los últimos cinco eventos de registro**  
En el mismo símbolo del sistema, ejecute el siguiente script para obtener los últimos cinco eventos de registro.  

```
./get-logs.sh
```
Debería ver los siguientes datos de salida:  

```
{
    "StatusCode": 200,
    "ExecutedVersion": "$LATEST"
}
{
    "events": [
        {
            "timestamp": 1559763003171,
            "message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version: $LATEST\n",
            "ingestionTime": 1559763003309
        },
        {
            "timestamp": 1559763003173,
            "message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tENVIRONMENT VARIABLES\r{\r  \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003173,
            "message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf\tINFO\tEVENT\r{\r  \"key\": \"value\"\r}\n",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003218,
            "message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
            "ingestionTime": 1559763018353
        },
        {
            "timestamp": 1559763003218,
            "message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration: 26.73 ms\tBilled Duration: 27 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",
            "ingestionTime": 1559763018353
        }
    ],
    "nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
    "nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}
```

## Eliminación de registros
<a name="csharp-logging-delete"></a>

Los grupos de registro no se eliminan automáticamente cuando se elimina una función. Para evitar almacenar registros indefinidamente, elimine el grupo de registros o [configure un periodo de retención](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SettingLogRetention) después de lo cual los registros se eliminan automáticamente.