Uso de expresiones regulares al consultar datos

Puedes utilizar expresiones regulares (regex) al consultar datos de IBM Cloud Logs para la búsqueda de patrones y la sustitución de cadenas.

Es posible que desee extraer datos específicos de sus registros para facilitar su análisis y visualización. A veces es posible que desee capturar datos registrados específicos. Otras veces, es posible que necesite ocultar datos confidenciales en los registros antes de que se guarden.

También puede hacer coincidir utilizando un patrón de expresión regular en lugar de una búsqueda de texto exacto.

¿Qué es una expresión regular y cómo funciona?

Las expresiones regulares, también conocidas como regex, son un lenguaje específico de dominio (DSL) utilizado para búsquedas y reemplazos de patrones.

La información de este tema no pretende ofrecer un tutorial educativo completo sobre expresiones regulares. Si no está familiarizado con las expresiones regulares, puede que quiera revisar la información disponible públicamente sobre expresiones regulares antes de intentar comprender los conceptos específicos incluidos aquí.

Conceptos de Regex

Hay algunos conceptos básicos que necesita conocer para entender los ejemplos de este tema.

Capturar grupo: Expresión regular contenida entre paréntesis. Los operadores se aplican al texto que coincide con la especificación entre paréntesis.
Grupo de captura con nombre: Un grupo de captura que está asociado con un nombre. Los resultados coincidentes pueden ser referenciados por el nombre
Clase de carácter: Una serie de caracteres que se deben combinar entre corchetes ( [] ). Se puede utilizar un guion como abreviatura para enumerar varios caracteres: [1-5] es lo mismo que [12345].

Cuándo usar regex

Hay ocasiones en las que no necesitará una expresión regular y podrá simplemente buscar un texto específico. Por ejemplo, si solo desea encontrar líneas de registro con el texto " user logged in ", puede simplemente introducir este texto en su búsqueda de registro. Pero si sus líneas de registro tienen este aspecto: user_32 logged in, no puede buscar el texto exacto, ya que el ID de usuario es una variable que cambia.

Afortunadamente, existe un patrón de expresiones regulares para este caso que hace uso de la secuencia match anything (coincidir con cualquier cosa):

user_d+ logged in

Uso de expresiones regulares para extraer texto en campos JSON personalizados

Supongamos que tiene un registro no estructurado con el siguiente formato:

${logLevel}: World-${worldName}: ${logText}

Y, le gustaría convertir todas las entradas en este formato en un objeto JSON en el siguiente formato:

{
    "level": `${log-level}`,
    "tag": `World-${worldName}`,
    "text": `${logText}`
}

Puede utilizar esta expresión regular para realizar la conversión:

^(?P.*?):s*(?P.*?):

Donde:

^ es el símbolo de inicio de línea, significa que la coincidencia debe comenzar con el inicio de una línea.
(?PX) donde X es lo que se empareja y es la sintaxis del grupo de captura nombrado. Esta expresión regular tiene tres grupos de captura, uno para cada clave JSON necesaria.
s significa «cualquier carácter de espacio en blanco».
. significa «cualquier carácter».
* significa «0 o más coincidencias del símbolo o carácter anterior».
.* significa «1 o más coincidencias del símbolo o carácter anterior».
.*? significa «cualquier carácter, cualquier número de veces, con la menor cantidad de fichas necesarias».

Por lo tanto, la expresión regular:

^(?P.*?):s*(?P.*?):

Se procesarán de la siguiente manera:

El texto que comienza al inicio de una línea hasta el primer símbolo de e : o se capturará como el grupo de e level o.
Después de cualquier número de espacios en blanco, cualquier texto hasta el siguiente símbolo de comilla simple ( : ) se capturará como el grupo de comillas dobles ( tag ).
IBM Cloud Logs establece automáticamente el texto de registro en el campo text, por lo que automáticamente tendremos el campo text.

Usando la misma expresión regular, el siguiente registro:

"info: World-w-8: generate: new world"

Se convierte en este objeto JSON:

{
   "level": "info",
   "tag": "World-w-8",
   "text": "info: World-w-8: generate: new world"
}

Extraer texto en campos predefinidos

Es posible que desee extraer texto en campos predefinidos. Considere este registro:

"info: World-w-8: generate: new world"

Es posible que desee extraer el texto info en la columna Severity, y el texto World en la columna Class.

Puede modificar la expresión regular para establecer los nombres correctos de los grupos de captura de la siguiente manera:

^(?P.*?):s*(?P.*?)-(?P.*?):

Esta expresión regular formateará el registro para que se muestre como se muestra.

Vista de ejemplo que muestra el registro con formato — Visualización del registro después de aplicar el formato regex

Extraer datos específicos de registros estructurados

Se puede utilizar un método similar para extraer datos de registros estructurados. El siguiente es un ejemplo que muestra cómo extraer datos de un campo JSON específico.

Supongamos que tiene una línea de registro estructurada similar a esta:

{
    "type": `${text}`,
    "log": `${text}`,
    "region": "rg-europe-2"
}

Ahora, si el campo region tiene la siguiente forma:

`rg-${"europe"|"asia"|"na"}-${number}`

Queremos extraer la parte que nos dice si la región es europe, asia o na. La expresión regular para extraer los datos sería:

"region"s*:s*"rg-(?P.*?)-

El grupo de captura nombrado regionName es el que extrae el texto. El nombre de la región va después del nombre de la clave region y los caracteres rg- según nuestro formato. El propósito de los símbolos de escape ( s* ) es hacer que regex siga funcionando si hay espacios en blanco antes o después del símbolo de escape ( : ).

El resultado será similar al siguiente:

{
    "log" : "Bye",
    "regionName" : "na",
    "region" : "rg-na-1",
    "type" : "ltest-w-9"
}

Sustitución y eliminación de valores

Uno de los ejemplos más comunes en los que necesitamos reemplazar o eliminar valores es ocultar datos personales. Supongamos que registra números de teléfono en algún lugar y no quiere que se guarden en IBM Cloud Logs.

Supongamos que tenemos una línea de registro no estructurada como esta:

"info: Sender: sendSms: sending sms to phone number +12345678910 to user Andrew"

Desea eliminar el número de teléfono y el nombre de esta línea. Esta expresión regular coincidirá con la línea, que comienza con «sending sms»:

sending sms to phone number +*d+ to user .*

Necesitamos escapar del símbolo + un espacio en blanco porque + tiene un significado especial en la sintaxis regex. Este significado es «1 o más caracteres anteriores».

El símbolo d coincide con cualquier dígito. Recuerde que el símbolo " * " significa "0 o más caracteres anteriores". Por lo tanto, +*d+ coincide con uno o más dígitos a los que se les puede anteponer un símbolo de porcentaje ( + ) (o no).

Esta expresión regular reemplazará el texto que coincide con la expresión regular anterior por el mismo texto, pero sin el número de teléfono ni el nombre:

sending sms to phone number * to user *

Y este es el resultado de aplicar la regla anterior:

"info: Sender: sendSms: sending sms to phone number * to user *"

Sustitución de valores JSON en registros estructurados

Sustituir valores JSON en registros estructurados es similar a sustituir valores en registros no estructurados. La cadena JSON completa se utiliza como entrada para la regla Reemplazar.

Utilizando la siguiente estructura JSON:

{
   "type": `${text}`,
   "log": `${text}`,
   "region": "rg-europe-2"
}

Supongamos que necesita reemplazar el valor del campo " type " por otro valor. A continuación, se explica cómo puede hacer coincidir el valor del campo " type ":

"type"s*:s*".*?"

Recuerde que necesitamos los símbolos " s* " para asegurarnos de que la expresión regular funciona si hay espacios en blanco antes o después del carácter " : ".

Esta es la expresión regular para reemplazar cualquier valor en el campo " type " con " newType ":

"type":"newType"

Uso de referencias cruzadas

Supongamos que necesitamos reemplazar europe por eu en las cadenas en el formato west-europe-2. Y supongamos que necesitamos hacer esto no solo en el campo " region " sino en cualquier otra parte del registro donde se encuentre la cadena. Coincidir con este patrón es fácil con esta expresión regular:

.+?-europe-d+

Sin embargo, sustituir la cadena utilizando los métodos que utilizamos antes podría ser bastante difícil. Esto se debe a que necesitamos insertar dos cadenas antes y después del texto " europe ", y esas cadenas pueden variar. Para ello, primero tenemos que capturar las cadenas en grupos de captura:

(.+?)-europe-(d+)

Recuerde que el símbolo d significa «cualquier dígito» y junto con + significa «cualquier dígito una o más veces». De manera similar, un .+, es cualquier símbolo una o más veces, pero con la menor cantidad de fichas para hacer la combinación.

Esta expresión regular capturará el texto antes de europe como grupo de captura 1, y el texto después de europe como grupo de captura 2. La siguiente expresión regular utilizará referencias inversas para insertar el contenido coincidente de esos grupos:

$1-eu-$2

Por ejemplo, un registro antes de aplicar nuestra regla:

{
    "log" : "Here region is east-europe-1. That's it",
    "type" : "newType",
    "region" : "east-europe-1"
}

Y el registro después de aplicar la regla:

{
    "log" : "Here region is east-eu-1. That's it",
    "type" : "newType",
    "region" : "east-eu-1"
}

Buscar usando regex desde la barra de búsqueda de registros

Otro lugar donde puede utilizar regex es la barra de búsqueda de la página de registros de la interfaz de usuario ( IBM Cloud Logs )

Al buscar desde la barra de búsqueda de la página, puede introducir texto exacto, Lucene o consultas Dataprime. También puede buscar patrones concretos utilizando expresiones regulares. Las consultas de Regex tienen su propio formato, que es:

/${fieldName}.keyword:/REGEX//

Supongamos que tenemos muchos registros estructurados en JSON con el siguiente formato:

{
    "log":  `${text}` ,
    "regionName":  `${text}`,
    "region":  `${text}`,
    "type"  :  `ltest-w-${number}`
}

Y queremos que coincidan solo aquellas entradas en las que type es igual a ltest-w-1, ltest-w-2 o ltest-w-3. La siguiente consulta de búsqueda lo hará:

/type.keyword:/ltest-w-[1-3]//

El texto entre corchetes [ y ] se denomina clase de caracteres. Coincide con cualquier carácter listado entre corchetes. El guión puede utilizarse como abreviatura para enumerar varios caracteres: [1-5] es lo mismo que [12345].

Puede utilizar la misma sintaxis para hacer coincidir datos en registros no estructurados con expresiones regulares. Solo tiene que establecer el nombre del campo como text.keyword. Por ejemplo:

 /text.keyword:/.*ltest-w-[1-3].*//

Esta expresión regular buscará el texto ltest-w-1, ltest-w-2 o ltest-w-3 en el cuerpo principal del registro.

Activación de alertas con expresiones regulares

Otro caso de uso popular de las expresiones regulares en IBM Cloud Logs es la definición de alertas. La sintaxis de las alertas es la misma que la de las consultas de registros.

Supongamos que queremos que nos avise en una línea del siguiente formulario:

`App: init: World-${name}: generation error: ${err}`

Y supongamos que queremos recibir alertas solo para los mundos w-1, w-2, w-3 o w-4. Nuestra expresión regular de alerta tendrá este aspecto:

/text.keyword:/.*World-w-[1-4]: generation error.*//

Recuerde que [1-4] coincide con cualquier carácter único desde 1 hasta 4, y .* coincide con cualquier carácter cualquier número de veces.

Para obtener más información sobre las alertas, consulte: