.*?)/ | stats avg(latency2) by @method2,
@user2
```
**Extrae los campos `loggingTime`, `loggingType` y `loggingMessage`, filtra hasta los eventos de registro que contienen cadenas `ERROR` o `INFO` y, a continuación, muestra solo los campos `loggingMessage` y `loggingType` para los eventos que contienen una cadena `ERROR`.**
```
FIELDS @message
| PARSE @message "* [*] *" as loggingTime, loggingType, loggingMessage
| FILTER loggingType IN ["ERROR", "INFO"]
| DISPLAY loggingMessage, loggingType = "ERROR" as isError
```
# sort
Use `sort` para mostrar eventos de registro en orden ascendente (`asc`) o descendente (`desc`) por un campo especificado. Puede usarlo con el comando `limit` para crear consultas de los “primeros N” o los “últimos N”.
El algoritmo de clasificación es una versión actualizada de la clasificación natural. Si ordena en orden ascendente, se utiliza la siguiente lógica.
+ Todos los valores no numéricos aparecen antes que todos los valores numéricos. Los *valores numéricos* son valores que incluyen únicamente números, no una mezcla de números y otros caracteres.
+ Para los valores que no son numéricos, el algoritmo agrupa los caracteres numéricos consecutivos y los caracteres alfabéticos consecutivos en fragmentos separados para compararlos. Ordena las partes no numéricas por sus valores Unicode y ordena las partes numéricas primero por su longitud y, después, por su valor numérico.
Para obtener más información sobre el orden Unicode, consulte [Lista de caracteres Unicode](https://en.wikipedia.org/wiki/List_of_Unicode_characters).
Por ejemplo, la información siguiente es el resultado de una clasificación en orden ascendente.
```
!: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sorted by unicode order
#
*%04
0# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Alphanumeric starting with numbers
5A
111A >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Starts with more digits than 5A, so it sorted to be later than 5A
2345_
@ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2345 is compared with @ in the unicode order,
@_
A >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Values starting with letters
A9876fghj
a12345hfh
0 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Number values
01
1
2
3
```
Si ordena en orden descendente, los resultados de la clasificación se invertirán.
Por ejemplo, la siguiente consulta para los registros de flujo de Amazon VPC busca las 15 transferencias principales de paquetes entre hosts.
```
stats sum(packets) as packetsTransferred by srcAddr, dstAddr
| sort packetsTransferred desc
| limit 15
```
# stats
Utilice `stats` para crear visualizaciones de los datos de registro, como gráficos de barras, gráficos de líneas y gráficos de áreas apiladas. Esto le ayuda a identificar de forma más eficiente los patrones en los datos de registro. CloudWatch Logs Insights genera visualizaciones para las consultas que utilizan la `stats` función y una o más funciones de agregación.
Por ejemplo, la siguiente consulta en un grupo de registro de Route 53 devuelve visualizaciones que muestran la distribución de los registros de Route 53 por hora, por tipo de consulta.
```
stats count(*) by queryType, bin(1h)
```
Todas estas consultas pueden generar gráficos de barras. Si la consulta utiliza la función `bin()` para agrupar los datos en función de un mismo campo a lo largo del tiempo, también puede ver gráficos de líneas y gráficos de áreas apiladas.
La función `bin` admite las siguientes unidades de tiempo y abreviaturas. Para todas las unidades y abreviaturas que incluyan más de un carácter, se admite agregar s para pluralizar. Así que tanto `hr` como `hrs` funcionan para especificar las horas.
+ `millisecond` `ms` `msec`
+ `second` `s` `sec`
+ `minute` `m` `min`
+ `hour` `h` `hr`
+ `day` `d`
+ `week` `w`
+ `month` `mo` `mon`
+ `quarter` `q` `qtr`
+ `year` `y` `yr`
**Topics**
+ [Visualización de datos de series temporales](#CWL_Insights-Visualizing-TimeSeries)
+ [Visualización de datos de registro agrupados por campos](#CWL_Insights-Visualizing-ByFields)
+ [Utilice varios comandos de estadísticas en una sola consulta](#CWL_QuerySyntax-stats-multi)
+ [Funciones para usar con estadísticas](#CWL_QuerySyntax-stats-functions)
## Visualización de datos de series temporales
Las visualizaciones de series temporales funcionan con las consultas que tienen las siguientes características:
+ La consulta contiene una o varias funciones de agregación. Para obtener más información, consulte [Aggregation Functions in the Stats Command](#CWL_Insights_Aggregation_Functions).
+ La consulta utiliza la función `bin()` para agrupar los datos por un campo.
Estas consultas pueden generar gráficos de líneas, de áreas apiladas, de barras y circulares.
**Ejemplos**
Para ver un tutorial completo, consulte [Tutorial: Ejecutar una consulta que produce una visualización de serie temporal](CWL_AnalyzeLogData_VisualizationQuery.md).
Aquí hay más consultas de ejemplo que funcionan para la visualización de series temporales.
La siguiente consulta genera una visualización de los valores medios del campo `myfield1`, con un punto de datos creado cada cinco minutos. Cada punto de datos es la agregación de las medias de los valores `myfield1` de los registros de los últimos cinco minutos.
```
stats avg(myfield1) by bin(5m)
```
La siguiente consulta genera una visualización de los tres valores basados en diferentes campos, con un punto de datos creado cada cinco minutos. La visualización se genera porque la consulta contiene las funciones de agregación y utiliza `bin()` como campo de agrupación.
```
stats avg(myfield1), min(myfield2), max(myfield3) by bin(5m)
```
**Restricciones de los gráficos de líneas y de áreas apiladas**
Las consultas que agregan información de entradas de registro pero no utilizan la función `bin()` pueden generar gráficos de barras. Sin embargo, las consultas no pueden generar gráficos de líneas ni gráficos de áreas apiladas. Para obtener más información sobre estos tipos de consultas, visite [Visualización de datos de registro agrupados por campos](#CWL_Insights-Visualizing-ByFields).
## Visualización de datos de registro agrupados por campos
Puede generar gráficos de barras para consultas que utilizan la función `stats` y una o varias funciones de agregación. Para obtener más información, consulte [Aggregation Functions in the Stats Command](#CWL_Insights_Aggregation_Functions).
Para ver la visualización, ejecute la consulta. A continuación, elija la pestaña **Visualization (Visualización)**, seleccione la flecha situada junto a **Line (Línea)** y haga clic en **Bar (Barra)**. Las visualizaciones de los gráficos de barras tienen un límite máximo de 100 barras.
**Ejemplos**
Para ver un tutorial completo, consulte [Tutorial: Ejecutar una consulta que produce una visualización agrupada por campos de registro](CWL_AnalyzeLogData_VisualizationFieldQuery.md). Los párrafos siguientes incluyen más consultas de ejemplo de visualizaciones por campos.
La siguiente consulta de registro de flujo de VPC busca el número medio de bytes transferidos por sesión en cada dirección de destino.
```
stats avg(bytes) by dstAddr
```
También puede generar un gráfico que contenga varias barras para cada valor resultante. Por ejemplo, la siguiente consulta de registro de flujo de VPC busca el número medio y máximo de bytes transferidos por sesión en cada dirección de destino.
```
stats avg(bytes), max(bytes) by dstAddr
```
En la siguiente consulta, se busca el número de registros de Amazon Route 53 para cada tipo de consulta.
```
stats count(*) by queryType
```
## Utilice varios comandos de estadísticas en una sola consulta
Puede usar hasta dos comandos `stats` en una sola consulta. Esto le permite realizar una agregación adicional en el resultado de la primera agregación.
**Ejemplo: consulta con dos comandos `stats`**
Por ejemplo, la siguiente consulta busca primero el volumen de tráfico total en los intervalos de 5 minutos y, a continuación, calcula el volumen de tráfico más alto, más bajo y medio de esos intervalos de 5 minutos.
```
FIELDS strlen(@message) AS message_length
| STATS sum(message_length)/1024/1024 as logs_mb BY bin(5m)
| STATS max(logs_mb) AS peak_ingest_mb,
min(logs_mb) AS min_ingest_mb,
avg(logs_mb) AS avg_ingest_mb
```
**Ejemplo: combine varios comandos de estadísticas con otras funciones, como `filter`, `fields`, `bin`**
Puede combinar dos comandos `stats` con otros comandos, como `filter` y `fields`, en una sola consulta. Por ejemplo, la siguiente consulta busca el número de direcciones IP distintas en las sesiones y busca el número de sesiones por plataforma de cliente, filtra esas direcciones IP y, finalmente, busca el promedio de solicitudes de sesión por plataforma del cliente.
```
STATS count_distinct(client_ip) AS session_ips,
count(*) AS requests BY session_id, client_platform
| FILTER session_ips > 1
| STATS count(*) AS multiple_ip_sessions,
sum(requests) / count(*) AS avg_session_requests BY client_platform
```
Puede utilizar funciones `bin` y `dateceil` en consultas con varios comandos `stats`. Por ejemplo, la siguiente consulta combina primero los mensajes en bloques de 5 minutos, luego agrega esos bloques de 5 minutos en bloques de 10 minutos y calcula los volúmenes de tráfico más altos, más bajos y promedio dentro de cada bloque de 10 minutos.
```
FIELDS strlen(@message) AS message_length
| STATS sum(message_length) / 1024 / 1024 AS logs_mb BY BIN(5m) as @t
| STATS max(logs_mb) AS peak_ingest_mb,
min(logs_mb) AS min_ingest_mb,
avg(logs_mb) AS avg_ingest_mb BY dateceil(@t, 10m)
```
**Notas y limitaciones**
Una consulta puede tener un máximo de dos comandos `stats`. Esta cuota no se puede cambiar.
Si utiliza un comando `sort` o `limit`, debe aparecer después del segundo comando `stats`. Si está antes del segundo comando `stats`, la consulta no es válida.
Cuando una consulta tiene dos comandos `stats`, los resultados parciales de la consulta no comienzan a mostrarse hasta que se completa la primera agregación `stats`.
En el segundo comando `stats` de una consulta única, solo puede hacer referencia a los campos definidos en el primer comando `stats`. Por ejemplo, la siguiente consulta no es válida porque el campo `@message` no estará disponible después de la primera agregación `stats`.
```
FIELDS @message
| STATS SUM(Fault) by Operation
# You can only reference `SUM(Fault)` or Operation at this point
| STATS MAX(strlen(@message)) AS MaxMessageSize # Invalid reference to @message
```
Todos los campos a los que haga referencia después del primer comando `stats` deben definirse en ese primer comando `stats`.
```
STATS sum(x) as sum_x by y, z
| STATS max(sum_x) as max_x by z
# You can only reference `max(sum_x)`, max_x or z at this point
```
**importante**
La función `bin` siempre utiliza el campo `@timestamp` de forma implícita. Esto significa que no se puede usar `bin` en el segundo comando `stats` sin usar el primer comando `stats` para propagar el campo `timestamp`. Por ejemplo, la siguiente consulta no es válida.
```
FIELDS strlen(@message) AS message_length
| STATS sum(message_length) AS ingested_bytes BY @logStream
| STATS avg(ingested_bytes) BY bin(5m) # Invalid reference to @timestamp field
```
En su lugar, defina el campo `@timestamp` en el primer comando `stats` y, a continuación, podrá usarlo con `dateceil` en el segundo comando `stats`, como en el siguiente ejemplo.
```
FIELDS strlen(@message) AS message_length
| STATS sum(message_length) AS ingested_bytes, max(@timestamp) as @t BY @logStream
| STATS avg(ingested_bytes) BY dateceil(@t, 5m)
```
## Funciones para usar con estadísticas
CloudWatch Logs Insights admite funciones de agregación de estadísticas y funciones de no agregación de estadísticas.
Utilice las funciones de agregación de estadísticas en el comando `stats` y como argumentos para otras funciones.
| Función | Tipo de resultado | Description (Descripción) |
| --- | --- | --- |
| `avg(fieldName: NumericLogField)` | número | La media de los valores en el campo especificado. |
| `count()` `count(fieldName: LogField)` | número | Cuenta los eventos de registro. `count()` (o `count(*)`) cuenta todos los eventos devueltos por la consulta, mientras que `count(fieldName)` cuenta todos los registros que incluyen el nombre de campo especificado. |
| `count_distinct(fieldName: LogField)` | número | Devuelve el número de valores únicos para el campo. Si el campo tiene una cardinalidad muy alta (contiene muchos valores únicos), el valor devuelto por `count_distinct` es solo una aproximación. |
| `max(fieldName: LogField)` | LogFieldValue | El máximo de los valores para este campo de registro en los registros consultados. |
| `min(fieldName: LogField)` | LogFieldValue | El mínimo de los valores para este campo de registro en los registros consultados. |
| `pct(fieldName: LogFieldValue, percent: number)` | LogFieldValue | Un percentil indica el peso relativo de un valor en un conjunto de datos. Por ejemplo, `pct(@duration, 95)` devuelve el valor `@duration` en que el 95 % de los valores de `@duration` son inferiores a este valor y un 5 por ciento son superiores a este valor. |
| `stddev(fieldName: NumericLogField)` | número | El desvío estándar de los valores en el campo especificado. |
| `sum(fieldName: NumericLogField)` | número | La suma de los valores en el campo especificado. |
**Funciones sin agregación de estadísticas**
Utilice las funciones de no agregación en el comando `stats` y como argumentos para otras funciones.
| Función | Tipo de resultado | Description (Descripción) |
| --- | --- | --- |
| `earliest(fieldName: LogField)` | LogField | Devuelve el valor de `fieldName` desde el evento de registro que tiene la primera marca temporal en los registros consultados. |
| `latest(fieldName: LogField)` | LogField | Devuelve el valor de `fieldName` desde el evento de registro que tiene la última marca temporal en los registros consultados. |
| `sortsFirst(fieldName: LogField)` | LogField | Devuelve el valor de `fieldName` que ordena en primer lugar los registros consultados. |
| `sortsLast(fieldName: LogField)` | LogField | Devuelve el valor de `fieldName` que ordena al final los registros consultados. |
# límite
Use `limit` para especificar el número de eventos de registro que desea que devuelva la consulta. Si omite `limit`, la consulta devolverá hasta 10 000 eventos de registro en los resultados.
Por ejemplo, el siguiente ejemplo devuelve solo los 25 eventos de registro más recientes
```
fields @timestamp, @message | sort @timestamp desc | limit 25
```
# dedup
Utilice `dedup` para eliminar los resultados duplicados en función de valores específicos en los campos que indique. Puede utilizar `dedup` con uno o más campos. Si especifica un campo con `dedup`, solo se devolverá un evento de registro por cada valor único de ese campo. Si especifica varios campos, se devolverá un evento de registro por cada combinación única de valores para esos campos.
Los resultados duplicados se descartan según el orden de clasificación y solo se conserva el primer resultado del orden de clasificación. Le recomendamos que ordene los resultados antes de someterlos al comando `dedup`. Si los resultados no se ordenan antes de analizarlos con `dedup`, se utiliza el orden de clasificación descendente predeterminado de `@timestamp`.
Los valores nulos no se consideran duplicados para la evaluación. Se conservan los eventos de registro con valores nulos para cualquiera de los campos especificados. Para eliminar campos con valores nulos, utilice **`filter`** mediante la función `isPresent(field)`.
El único comando de consulta que puede utilizar en una consulta después del comando `dedup` es `limit`.
Cuando se utiliza `dedup` en una consulta, la consola muestra un mensaje como **Mostrar X de Y registros, donde X** es el número de resultados deduplicados e Y es el número total de registros coincidentes antes de la deduplicación. Esto indica que se eliminaron los registros duplicados y no significa que falten datos.
**Ejemplo: Vea solo el evento de registro más reciente para cada valor único del campo denominado `server`**
En el siguiente ejemplo, se muestran los campos `timestamp`, `server`, `severity` y `message` solo para el evento más reciente de cada valor único de `server`.
```
fields @timestamp, server, severity, message
| sort @timestamp desc
| dedup server
```
Para ver más ejemplos de consultas de CloudWatch Logs Insights, consulte[Consultas generales](CWL_QuerySyntax-examples.md#CWL_QuerySyntax-examples-general).
# unmask
`unmask` se utiliza para mostrar todo el contenido de un evento de registro que tiene parte del contenido enmascarado debido a una política de protección de datos. Para ejecutar este comando, debe tener el permiso `logs:Unmask`.
Para obtener más información sobre la protección de datos en grupos de registro, consulte [Ayude a proteger los datos de registro confidenciales con el enmascaramiento](mask-sensitive-log-data.md).
# unnest
Se debe utilizar `unnest` para aplanar una lista tomada como entrada y generar varios registros con un único registro para cada elemento de la lista. En función de la cantidad de elementos que contenga un campo, este comando descarta el registro actual y genera nuevos registros. Cada registro incluye el `unnested_field`, que representa un elemento. Todos los demás campos provienen del registro original.
La entrada para `unnest` es `LIST`, que proviene de la función `jsonParse`. Para obtener más información, consulte [Tipos de estructura](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax-operations-functions.html#CWL_QuerySyntax-structure-types). Cualquier otro tipo, como `MAP`, `String` y `numbers`, se trata como una lista con un elemento en `unnest`.
**Estructura de comandos**
En el ejemplo siguiente, se describe el formato de este comando.
```
unnest field into unnested_field
```
**Consulta de ejemplo**
En el siguiente ejemplo, se analiza una cadena de objeto JSON y se amplía una lista de eventos de campo.
```
fields jsonParse(@message) as json_message
| unnest json_message.events into event
| display event.name
```
El evento de registro de esta consulta de ejemplo podría ser una cadena JSON de la siguiente manera:
```
{
"events": [
{
"name": "exception"
},
{
"name": "user action"
}
]
}
```
En este caso, la consulta de ejemplo genera dos registros en el resultado de la consulta, uno con `event.name` como `exception` y otro con `event.name` como **acción del usuario**
**Consulta de ejemplo**
En el siguiente ejemplo, se aplana una lista y, a continuación, se filtran los elementos.
```
fields jsonParse(@message) as js
| unnest js.accounts into account
| filter account.type = "internal"
```
**Consulta de ejemplo**
En el siguiente ejemplo, se aplana una lista para su agregación.
```
fields jsonParse(trimmedData) as accounts
| unnest accounts into account
| stats sum(account.droppedSpans) as n by account.accountId
| sort n desc
| limit 10
```
# lookup
Se utiliza `lookup` para enriquecer los resultados de la consulta con datos de referencia de una tabla de consulta. Una tabla de consulta contiene datos CSV que subes a Amazon CloudWatch Logs. Cuando se ejecuta una consulta, el `lookup` comando compara un campo del registro de eventos con un campo de la tabla de consulta y agrega los campos de salida especificados a los resultados.
Utilice tablas de consulta para escenarios de enriquecimiento de datos, como mapear los detalles de un usuario IDs a otro, los códigos de producto a la información del producto o los códigos de error a las descripciones de los errores.
## Creación y administración de tablas de consulta
Antes de poder utilizar el `lookup` comando en una consulta, debe crear una tabla de consulta. Puede crear y gestionar tablas de búsqueda desde la CloudWatch consola o mediante la API de Amazon CloudWatch Logs.
**Para crear una tabla de consulta (consola)**
1. Abra la CloudWatch consola en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. En el panel de navegación, elija **Configuración** y, a continuación, elija la pestaña **Registros**.
1. Desplázate hasta **Tablas de búsqueda** y selecciona **Administrar**.
1. Seleccione **Crear tabla de consulta**.
1. Introduzca un nombre para la tabla de consulta. El nombre solo puede contener caracteres alfanuméricos, guiones y guiones bajos.
1. (Opcional) Introduzca una descripción.
1. Cargue un archivo CSV. El archivo debe incluir una fila de encabezado con los nombres de las columnas, utilizar la codificación UTF-8 y no superar los 10 MB.
1. (Opcional) Especifique una AWS KMS clave para cifrar los datos de la tabla.
1. Seleccione **Crear**.
Después de crear una tabla de consulta, puede verla en el editor de consultas de CloudWatch Logs Insights. Seleccione la pestaña **Tablas de búsqueda** para buscar las tablas disponibles y sus campos.
Para actualizar una tabla de consulta, selecciónela y elija **Acciones**, **Actualizar**. Cargue un nuevo archivo CSV para reemplazar todo el contenido existente. Para eliminar una tabla de consulta, selecciona **Acciones**, **Eliminar**.
**nota**
Puede crear hasta 100 tablas de búsqueda por cuenta y por cuenta Región de AWS. Los archivos CSV pueden ocupar hasta 10 MB. También puedes gestionar las tablas de búsqueda mediante la API de Amazon CloudWatch Logs. Para obtener más información, consulta [CreateLookupTable](https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CreateLookupTable.html)la *referencia de la API CloudWatch de Amazon Logs*.
**nota**
Si la tabla de consulta está cifrada con una clave de KMS, la persona que llama debe tener el `kms:Decrypt` permiso sobre la clave (la clave de KMS utilizada para cifrar la tabla de consulta) para utilizar la `StartQuery` API con una consulta que haga referencia a esa tabla de consulta. Para obtener más información, consulte [Cifre las tablas de búsqueda en CloudWatch los registros mediante AWS Key Management Service](encrypt-lookup-tables-kms.md).
## Sintaxis de consulta para la búsqueda
**Estructura de comandos**
A continuación se muestra el formato de este comando.
```
lookup table lookup-field as log-field [,...] output-mode output-field[,...]
```
El comando utiliza los siguientes argumentos:
+ `table`— El nombre de la tabla de consulta que se va a utilizar.
+ `lookup-field`— El campo de la tabla de consulta con el que se va a comparar.
+ `log-field`— El campo del registro de eventos que debe coincidir. La coincidencia es exacta y distingue mayúsculas de minúsculas.
+ `output-mode`— Especifique si `OUTPUT` desea añadir los campos de salida a los resultados. Si ya existe un campo con el mismo nombre en el registro de eventos, se sobrescribe.
+ `output-field`— Uno o más campos de la tabla de consulta para añadirlos a los resultados.
**Ejemplo: enriquece los eventos del registro con los detalles del usuario**
Supongamos que tiene un grupo de registros con eventos que contienen un `id` campo y una tabla de consulta `user_data` con las columnas `id``name`,`email`, y`department`. La siguiente consulta enriquece cada evento de registro con el nombre, el correo electrónico y el departamento del usuario de la tabla de búsqueda.
```
fields action, status, name, email, department
| lookup user_data id OUTPUT name, email, department
```
**Ejemplo: utilice la búsqueda con agregación**
Puede utilizar los campos de salida de la búsqueda con funciones de agregación. La siguiente consulta enriquece los eventos del registro con los detalles del usuario y, a continuación, cuenta los eventos agrupados por dirección de correo electrónico.
```
fields user_id, action, username, email, department
| lookup user_data user_id OUTPUT username, email, department
| stats count(*) by email
```
**Ejemplo: utilice la búsqueda con un filtro**
Puede filtrar los resultados en función de los campos devueltos por la búsqueda. La siguiente consulta enriquece el registro de eventos y, a continuación, filtra para mostrar solo los eventos de un departamento específico.
```
fields user_id, action
| lookup user_data user_id OUTPUT username, email, department
| filter department = "Engineering"
```
# Funciones booleanas, de comparación, numéricas, de fecha y hora y otras
CloudWatch Logs Insights admite muchas otras operaciones y funciones en las consultas, como se explica en las siguientes secciones.
**Topics**
+ [Operadores aritméticos](#CWL_QuerySyntax-operations-arithmetic)
+ [Operadores booleanos](#CWL_QuerySyntax-operations-Boolean)
+ [Operadores de comparación](#CWL_QuerySyntax-operations-comparison)
+ [Operadores numéricos](#CWL_QuerySyntax-operations-numeric)
+ [Tipos de estructura](#CWL_QuerySyntax-structure-types)
+ [Funciones DateTime](#CWL_QuerySyntax-datetime)
+ [Funciones generales](#CWL_QuerySyntax-general-functions)
+ [Funciones JSON](#CWL_QuerySyntax-json-functions)
+ [Funciones de cadena de dirección IP](#CWL_QuerySyntax-IPaddress-functions)
+ [Funciones de cadena](#CWL_QuerySyntax-string-functions)
## Operadores aritméticos
Los operadores aritméticos aceptan tipos de datos numéricos como argumentos y devuelven resultados numéricos. Utilice operadores aritméticos en los comandos `filter` y `fields` y como argumentos para otras funciones.
| Operación | Description (Descripción) |
| --- | --- |
| `a + b` | Suma |
| `a - b` | Resta |
| `a * b` | Multiplicación |
| `a / b` | División |
| `a ^ b` | Potencia (`2 ^ 3` devuelve `8`) |
| `a % b` | Resto o módulo (`10 % 3` devuelve `1`) |
## Operadores booleanos
Utilice los operadores booleanos `and`, `or` y `not`.
**nota**
Utilice operadores booleanos solo en funciones que devuelvan el valor **TRUE** o **FALSE**.
## Operadores de comparación
Los operadores de comparación aceptan todos los tipos de datos como argumentos y devuelven un resultado booleano. Utilice operadores de comparación en el comando `filter` y como argumentos para otras funciones.
| Operador | Description (Descripción) |
| --- | --- |
| `=` | Igualdad |
| `!=` | Desigualdad |
| `<` | Menor que |
| `>` | Mayor que |
| `<=` | Menor o igual que |
| `>=` | Mayor o igual que |
## Operadores numéricos
Las operaciones numéricas aceptan tipos de datos numéricos como argumentos y devuelven resultados numéricos. Utilice operaciones numéricas en los comandos `filter` y `fields` y como argumentos para otras funciones.
| Operación | Tipo de resultado | Description (Descripción) |
| --- | --- | --- |
| `abs(a: number)` | número | Valor absoluto |
| `ceil(a: number)` | número | Redondeo a valor máximo (menor número entero que es mayor que el valor de `a`). |
| `floor(a: number)` | número | Redondeo a valor mínimo (mayor número entero que es menor que el valor de `a`). |
| `greatest(a: number, ...numbers: number[])` | número | Devuelve el valor más alto |
| `least(a: number, ...numbers: number[])` | número | Devuelve el valor más bajo |
| `log(a: number)` | número | Registro natural |
| `sqrt(a: number)` | número | Raíz cuadrada |
## Tipos de estructura
Un mapa o una lista es un tipo de estructura de CloudWatch Logs Insights que permite acceder a los atributos de las consultas y utilizarlos.
**Ejemplo: obtención de un mapa o una lista**
Se usa `jsonParse` para analizar un campo que es una cadena json y convertirlo en un mapa o una lista.
```
fields jsonParse(@message) as json_message
```
**Ejemplo: acceso a los atributos**
Utilice el operador de acceso por puntos (map.attribute) para acceder a los elementos de un mapa. Si un atributo de un mapa contiene caracteres especiales, utilice acentos graves para incluir el nombre del atributo (map.attributes.`special.char`).
```
fields jsonParse(@message) as json_message
| stats count() by json_message.status_code
```
Utilice el operador de acceso entre corchetes (list[index]) para recuperar un elemento en una posición específica de la lista.
```
fields jsonParse(@message) as json_message
| filter json_message.users[1].action = "PutData"
```
Coloque los caracteres especiales entre acentos graves (``) cuando haya caracteres especiales en el nombre de la clave.
```
fields jsonParse(@message) as json_message
| filter json_message.`user.id` = "123"
```
**Ejemplo: resultados vacíos**
Los mapas y las listas se consideran nulos para las funciones de cadena, número, y fecha y hora.
```
fields jsonParse(@message) as json_message
| display toupper(json_message)
```
La comparación del mapa y la lista con cualquier otro campo da como resultado `false`.
**nota**
No se admite el uso de mapas y listas en `dedup`, `pattern`,`sort` y `stats`.
## Funciones DateTime
**Funciones DateTime**
Utilice funciones datetime en los comandos `fields` y `filter` y como argumentos para otras funciones. Utilice estas funciones para crear buckets de hora para consultas con funciones de agregación. Utilice períodos de tiempo que tengan un número y uno de los siguientes valores:
+ `ms` para milisegundos
+ `s` para segundos
+ `m` para minutos
+ `h` para horas
Por ejemplo, `10m` es 10 minutos y `1h` es 1 hora.
**nota**
Utilice la unidad de tiempo más adecuada para su función de fecha y hora. CloudWatch Los registros limitan la solicitud en función de la unidad de tiempo que elija. Por ejemplo, pone un límite de 60 como valor máximo para cualquier solicitud que utilice `s`. Por lo tanto, si lo especificas`bin(300s)`, CloudWatch Logs en realidad lo implementa como 60 segundos, ya que 60 es el número de segundos en un minuto, por lo que CloudWatch Logs no utilizará un número superior a 60`s`. Para crear un bucket de 5 minutos, utilice `bin(5m)` en su lugar.
El límite de `ms` es 1000, el límite de `s` y `m` es 60 y el límite de `h` es 24.
En la siguiente tabla, se incluye una lista de las distintas funciones datetime que se pueden usar en comandos de consulta. La tabla enumera el tipo de resultado de cada función y contiene una descripción de cada función.
**sugerencia**
Al crear un comando de consulta, puede utilizar el selector de intervalos de tiempo para seleccionar un periodo de tiempo que desea consultar. Por ejemplo, puede establecer un periodo entre intervalos de 5 a 30 minutos; intervalos de 1, 3 y 12 horas; o un marco temporal personalizado. También puede establecer periodos de tiempo entre fechas específicas.
| Función | Tipo de resultado | Description (Descripción) |
| --- | --- | --- |
| `bin(period: Period)` | Timestamp | Redondea el valor de `@timestamp` según el periodo de tiempo indicado y, a continuación, trunca. Por ejemplo, `bin(5m)` redondea el valor de `@timestamp` a los 5 minutos más cercanos. Puede usarlo para agrupar varias entradas de registro en una consulta. En el siguiente ejemplo, se devuelve el número de excepciones por hora: filter @message like /Exception/
| stats count(*) as exceptionCount by bin(1h)
| sort exceptionCount desc
La función `bin` admite las siguientes unidades de tiempo y abreviaturas. Para todas las unidades y abreviaturas que incluyan más de un carácter, se admite agregar s para pluralizar. Así que tanto `hr` como `hrs` funcionan para especificar las horas. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonCloudWatch/latest/logs/CWL_QuerySyntax-operations-functions.html) |
| `datefloor(timestamp: Timestamp, period: Period)` | Timestamp | Trunca la marca temporal según el periodo indicado. Por ejemplo, `datefloor(@timestamp, 1h)` trunca todos los valores de `@timestamp` en la parte inferior de la hora. |
| `dateceil(timestamp: Timestamp, period: Period)` | Timestamp | Redondea hacia arriba la marca temporal según el periodo indicado y, a continuación, trunca. Por ejemplo, `dateceil(@timestamp, 1h)` trunca todos los valores de `@timestamp` en la parte superior de la hora. |
| `fromMillis(fieldName: number)` | Timestamp | Interpreta el campo de entrada como el número de milisegundos desde la fecha de inicio de Unix y lo convierte en una marca de tiempo. |
| `toMillis(fieldName: Timestamp)` | número | Convierte la marca de tiempo que se encontró en el campo con nombre asignado en un número que representa los milisegundos desde la fecha de inicio de Unix. Por ejemplo, `toMillis(@timestamp)` convierte la marca temporal `2022-01-14T13:18:031.000-08:00` a `1642195111000`. |
| `now()` | número | Devuelve la hora en que se inició el procesamiento de la consulta, en segundos por época. Esta función no toma argumentos. Puede usarlo para filtrar los resultados de la consulta según la hora actual. Por ejemplo, la siguiente consulta devuelve todos los errores 4xx de las últimas dos horas: parse @message "Status Code: *;" as statusCode\n
| filter statusCode >= 400 and statusCode <= 499 \n
| filter toMillis(@timestamp) >= (now() * 1000 - 7200000)
El ejemplo siguiente devuelve todas las entradas de registro de las últimas cinco horas que contienen la palabra `error` o `failure` fields @timestamp, @message
| filter @message like /(?i)(error|failure)/
| filter toMillis(@timestamp) >= (now() * 1000 - 18000000)
|
**nota**
Actualmente, CloudWatch Logs Insights no admite el filtrado de registros con marcas de tiempo legibles por humanos.
## Funciones generales
**Funciones generales**
Utilice funciones generales en los comandos `fields` y `filter` y como argumentos para otras funciones.
| Función | Tipo de resultado | Description (Descripción) |
| --- | --- | --- |
| `ispresent(fieldName: LogField)` | Booleano | Devuelve `true` si el campo existe |
| `coalesce(fieldName: LogField, ...fieldNames: LogField[])` | LogField | Devuelve el primer valor no nulo de la lista |
## Funciones JSON
**Funciones JSON**
Utilice funciones JSON en los comandos `fields` y `filter` y como argumentos para otras funciones.
| Función | Tipo de resultado | Description (Descripción) |
| --- | --- | --- |
| `jsonParse(fieldName: string)` | Mapa \$1 Lista \$1 Vacío | Devuelve un mapa o una lista cuando la entrada es una representación en cadena de un objeto JSON o una matriz JSON. Devuelve un valor vacío si la entrada no es una de las representaciones. |
| `jsonStringify(fieldName: Map \| List)` | Cadena | Devuelve una cadena JSON de un mapa o de una lista de datos. |
## Funciones de cadena de dirección IP
**Funciones de cadena de dirección IP**
Utilice funciones de cadena de dirección IP en los comandos `filter` y `fields` y como argumentos para otras funciones.
| Función | Tipo de resultado | Description (Descripción) |
| --- | --- | --- |
| `isValidIp(fieldName: string)` | booleano | Devuelve `true` si el campo es una IPv6 dirección IPv4 OR válida. |
| `isValidIpV4(fieldName: string)` | booleano | Devuelve `true` si el campo es una IPv4 dirección válida. |
| `isValidIpV6(fieldName: string)` | booleano | Devuelve `true` si el campo es una IPv6 dirección válida. |
| `isIpInSubnet(fieldName: string, subnet: string)` | booleano | Devuelve `true` si el campo es una IPv6 dirección IPv4 o dirección válida dentro de la subred v4 o v6 especificada. Al especificar la subred, utilice la notación CIDR como `192.0.2.0/24` o `2001:db8::/32`, donde `192.0.2.0` o `2001:db8::` es el inicio del bloque de CIDR. |
| `isIpv4InSubnet(fieldName: string, subnet: string)` | booleano | Devuelve `true` si el campo es una IPv4 dirección válida dentro de la subred v4 especificada. Al especificar la subred, utilice la notación CIDR como `192.0.2.0/24`, donde `192.0.2.0` es el inicio del bloque de CIDR. |
| `isIpv6InSubnet(fieldName: string, subnet: string)` | booleano | Devuelve `true` si el campo es una IPv6 dirección válida dentro de la subred v6 especificada. Al especificar la subred, utilice la notación CIDR como `2001:db8::/32`, donde `2001:db8::` es el inicio del bloque de CIDR. |
## Funciones de cadena
**Funciones de cadena**
Utilice funciones de cadena en los comandos `fields` y `filter` y como argumentos para otras funciones.
| Función | Tipo de resultado | Description (Descripción) |
| --- | --- | --- |
| `isempty(fieldName: string)` | Número | Devuelve `1` si el campo no se encuentra o es una cadena vacía. |
| `isblank(fieldName: string)` | Número | Devuelve `1` si el campo no se encuentra, es una cadena vacía o solo contiene espacio en blanco. |
| `concat(str: string, ...strings: string[])` | cadena | Concatena las cadenas. |
| `ltrim(str: string)` `ltrim(str: string, trimChars: string)` | cadena | Si la función no tiene un segundo argumento de cadena, elimina los espacios en blanco de la izquierda de la cadena. Si la función tiene un segundo argumento de cadena, no elimina espacios en blanco. En su lugar, elimina los caracteres de `trimChars` desde la izquierda de `str`. Por ejemplo, `ltrim("xyZxyfooxyZ","xyZ")` devuelve `"fooxyZ"`. |
| `rtrim(str: string)` `rtrim(str: string, trimChars: string)` | cadena | Si la función tiene un segundo argumento de cadena, elimina los espacios en blanco de la derecha de la cadena. Si la función tiene un segundo argumento de cadena, no elimina espacios en blanco. En su lugar, elimina los caracteres de `trimChars` desde la derecha de `str`. Por ejemplo, `rtrim("xyZfooxyxyZ","xyZ")` devuelve `"xyZfoo"`. |
| `trim(str: string)` `trim(str: string, trimChars: string)` | cadena | Si la función no tiene un segundo argumento, elimina espacios en blanco de ambos extremos de la cadena. Si la función tiene un segundo argumento de cadena, no elimina espacios en blanco. En su lugar, elimina los caracteres de `trimChars` desde ambos lados de `str`. Por ejemplo, `trim("xyZxyfooxyxyZ","xyZ")` devuelve `"foo"`. |
| `strlen(str: string)` | número | Devuelve la longitud de la cadena puntos de código Unicode. |
| `toupper(str: string)` | cadena | Convierte la cadena en mayúsculas. |
| `tolower(str: string)` | cadena | Convierte la cadena de caracteres en minúsculas. |
| `substr(str: string, startIndex: number)` `substr(str: string, startIndex: number, length: number)` | cadena | Devuelve una subcadena del índice especificado por el argumento numérico al final de la cadena. Si la función tiene un segundo argumento numérico, contiene la longitud de la subcadena que debe recuperarse. Por ejemplo, `substr("xyZfooxyZ",3, 3)` devuelve `"foo"`. |
| `replace(fieldName: string, searchValue: string, replaceValue: string)` | cadena | Sustituye todas las instancias de `searchValue` en `fieldName: string` por `replaceValue`. Por ejemplo, la función `replace(logGroup,"smoke_test","Smoke")` busca eventos de registro en los que el campo `logGroup` contiene el valor de cadena `smoke_test` y reemplaza el valor por la cadena `Smoke`. |
| `strcontains(str: string, searchValue: string)` | número | Devuelve 1 si `str` contiene `searchValue` y 0 en los demás casos. |
# Campos que contienen caracteres especiales
Si un campo contiene caracteres no alfanuméricos distintos al símbolo `@` o al punto (`.`), debe rodearlo con caracteres de comillas invertidas (```). Por ejemplo, el campo de registro `foo-bar` debe aparecer entre acentos graves (``foo-bar``), porque contiene un carácter no alfanumérico, el guion (`-`).
# Uso de alias y comentarios en las consultas
Cree consultas que contengan alias. Utilice alias para cambiar el nombre de los campos de registro o al extraer valores en campos. Utilice la palabra clave `as` para asignar un alias a un resultado o campo de registro. Puede utilizar más de un alias en una consulta. Puede utilizar alias en los siguientes comandos:
+ `fields`
+ `parse`
+ `sort`
+ ` stats `
En los siguientes ejemplos, se muestra cómo crear consultas que contienen alias.
**Ejemplo**
La consulta contiene un alias en el comando `fields`.
```
fields @timestamp, @message, accountId as ID
| sort @timestamp desc
| limit 20
```
La consulta devuelve los valores de los campos `@timestamp`, `@message` y `accountId`. Los resultados se muestran en orden descendente y su número se limita a 20. Los valores de `accountId` aparecen bajo el alias `ID`.
**Ejemplo**
La consulta contiene alias en los comandos `sort` y `stats`.
```
stats count(*) by duration as time
| sort time desc
```
La consulta cuenta el número de veces que el campo `duration` aparece en el grupo de registro y muestra los resultados en orden descendente. Los valores de `duration` aparecen bajo el alias `time`.
## Uso de comentarios
CloudWatch Logs Insights admite comentarios en las consultas. Utilice el carácter de la almohadilla (**\$1**) para desactivar los comentarios. Puede utilizar comentarios para que haga caso omiso de determinadas líneas en consultas o consultas de documentos.
**Ejemplo: consulta**
Cuando se ejecuta la siguiente consulta, se hace caso omiso de la segunda línea.
```
fields @timestamp, @message, accountId
# | filter accountId not like "7983124201998"
| sort @timestamp desc
| limit 20
```