Lenguaje de consulta de registro

En esta página, se describe el lenguaje de consulta de registro que se usa para consultar los datos de los registros y crear receptores de registros.

Las consultas se pueden usar en el panel del compilador de consultas de Cloud Logging en Google Cloud Console, la API de Logging o la interfaz de línea de comandos.

La sintaxis de consulta

En esta sección, se explica cómo se estructuran las consultas y cómo se realizan la coincidencias.

Las consultas son expresiones que pueden especificar un conjunto de entradas de registro de cualquier cantidad de registros. Una consulta es una expresión booleana que especifica un subconjunto de todas las entradas de registro en tu proyecto.

Puedes compilar consultas basadas en las siguientes cuatro dimensiones mediante los operadores lógicos AND y OR:

  • Recurso: Para obtener más información, consulta resource.type.
  • Nombre del registro: Para obtener más información, consulta logName.
  • Gravedad: Para obtener más información, consulta severity.
  • Intervalo de tiempo: Para obtener más información, consulta timestamp.

Para ver ejemplos de consultas comunes que te pueden interesar, ve a Ejemplos de consultas con el Explorador de registros.

Notación de la sintaxis

La sintaxis de consulta se describe mediante el uso de la siguiente notación:

  • a = e significa que a es un nombre para la expresión e.
  • a b significa “a seguida de b”.
  • a | b significa “a o b”.
  • ( e ) se usa para los grupos.
  • [ e ] significa que e es opcional.
  • { e } significa que e se puede repetir cero o más veces.
  • “abc” significa que abc se debe escribir tal como aparece.

Resumen de la sintaxis

En esta sección, se proporciona una descripción general de la sintaxis de consulta.

Una consulta es una string que contiene una expresión:

   expression = ["NOT"] comparison { ("AND" | "OR") ["NOT"] comparison }

Una comparación es un valor único o una expresión booleana:

  "The cat in the hat"
  resource.type = "gae_app"

La primera línea es un ejemplo de una comparación que es un valor único. Estos tipos de comparaciones son restricciones globales. Cada campo de una entrada de registro se compara con el valor mediante el uso implícito del operador has. Para este ejemplo, si algún campo en una LogEntry, o su carga útil, contiene la frase “The cat in the hat” (El gato en el sombrero), la comparación es exitosa.

La segunda línea es un ejemplo de una comparación que es una expresión booleana de la forma [FIELD_NAME] [OP] [VALUE]. Los elementos de la comparación se describen a continuación:

  • [FIELD_NAME]: Es un campo en una entrada de registro. Por ejemplo, resource.type.

  • [OP]: Es un operador de comparación. Por ejemplo, =.

  • [VALUE]: Es un número, una expresión entre paréntesis, una string o una función. Por ejemplo, "gae_app".

En las siguientes secciones, se brindan más detalles sobre las consultas y la coincidencia.

Operadores booleanos

Los operadores booleanos AND y OR son operadores de cortocircuito. El operador NOT tiene la prioridad más alta, seguido de OR y AND en ese orden. Por ejemplo, las dos expresiones siguientes son equivalentes:

a OR NOT b AND NOT c OR d
(a OR (NOT b)) AND ((NOT c) OR d)

Puedes omitir el operador AND entre las comparaciones. También puedes reemplazar el operador NOT por el operador - (menos). Por ejemplo, las siguientes dos consultas son equivalentes:

a=b AND c=d AND NOT e=f
a=b c=d -e=f

En esta documentación, siempre se usa AND y NOT.

Comparaciones

Las comparaciones tienen el formato siguiente:

[FIELD_NAME] [OP] [VALUE]

Los elementos de la comparación se describen a continuación:

  • [FIELD_NAME]: Es el nombre de la ruta de un campo en una entrada de registro. Los ejemplos del nombre de campo son los siguientes:

    resource.type
    resource.labels.zone
    resource.labels.project_id
    insertId
    jsonPayload.httpRequest.protocol
    labels."compute.googleapis.com/resource_id"
    

    Si un componente de un nombre de ruta de acceso tiene caracteres especiales, el nombre de la ruta debe estar entre comillas dobles. Por ejemplo, compute.googleapis.com/resource_id debe tener comillas dobles, porque contiene una barra diagonal /.

    Para obtener detalles, revisa la sección sobre identificadores de rutas de campo en esta página.

  • [OP]: Es un operador de comparación, uno de los siguientes:

    =           # equal
    !=          # not equal
    > < >= <=   # numeric ordering
    :           # "has" matches any substring in the log entry field
    =~          # regular expression search for a pattern
    !~          # regular expression search not for a pattern
    
  • [VALUE]: Es un número, una expresión entre paréntesis, una string o una función. Las strings se usan para representar textos arbitrarios, además de valores booleanos, de enumeración y de string de bytes. El [VALUE] se convierte al tipo de campo antes de la comparación.

Si [VALUE] es una combinación booleana de comparaciones entre paréntesis, entonces el nombre del campo y el operador de comparación se aplican a cada elemento. Por ejemplo:

    jsonPayload.cat = ("longhair" OR "shorthair")
    jsonPayload.animal : ("nice" AND "pet")

Con la primera comparación, se verifica que el campo cat tenga el valor “longhair” (cabello largo) o “shorthair” (cabello corto). Con la segunda, se comprueba que el valor del campo animal contenga las dos palabras “nice” (lindo) y “pet” (mascota), en cualquier orden.

Identificadores de rutas de acceso de campo

Todas las entradas de registro son instancias del tipo LogEntry. El identificador que es (o comienza en) el lado izquierdo de una comparación debe ser un campo definido en el tipo LogEntry. Para obtener detalles sobre los identificadores posibles y sus valores, revisa el tipo LogEntry.

A continuación, se muestra la lista actual de los campos de entrada de registro. Cada campo va seguido del nivel de nombres siguiente para ese campo, si corresponde:

  • httpRequest: { cacheFillBytes, cacheHit, cacheLookup, cacheValidatedWithOriginServer, latency, protocol, referer, remoteIp, requestMethod, requestSize, requestUrl, responseSize, serverIp, status, userAgent }
  • insertId
  • jsonPayload { variable }
  • labels { variable }
  • logName
  • metadata { systemLabels, userLabels }
  • operation{ id, producer, first, last }
  • protoPayload { @type, variable }
  • receiveTimestamp
  • resource { type, labels }
  • severity
  • sourceLocation: { file, line, function }
  • spanId
  • textPayload
  • timestamp
  • trace

Los siguientes son ejemplos de identificadores de rutas de campo que puedes usar en tus comparaciones:

  • resource.type: Si tu primer identificador de ruta es resource, el identificador siguiente debe ser un campo del tipo MonitoredResource.

  • httpRequest.latency: Si tu primer identificador de ruta es httpRequest, el siguiente identificador debe ser un campo del tipo HttpRequest.

  • labels.[KEY]: Si tu primer identificador de ruta es labels, el identificador siguiente, [KEY], debe ser una de las claves de los pares clave-valor que aparecen en el campo labels.

  • logName: Debido a que el campo logName es una string, no puede haber ningún nombre de subcampo luego de este.

Caracteres especiales

Si un campo LogEntry contiene caracteres especiales, el campo de registro debe estar entre comillas. Por ejemplo:

  jsonPayload.":name":apple

  jsonPayload."foo.bar":apple

  jsonPayload."\"foo\"":apple

Para obtener la lista de caracteres especiales, consulta la sección string en Valores y conversiones.

Para obtener más información sobre el uso de identificadores de rutas de campo que hacen referencia a objetos o arreglos, dirígete Tipos de objetos y arreglos en esta página.

Tipos de recursos supervisados

Para realizar consultas más rápidas, especifica un tipo de recurso supervisado. Para obtener una lista de los tipos de recursos, consulta Tipos de recursos supervisados.

Por ejemplo, las VM de Compute Engine usan el tipo de recurso gce_instance y las instancias de Amazon EC2 usan aws_ec2_instance. En el siguiente ejemplo, se muestra cómo limitar tus consultas a ambos tipos de VM:

    resource.type = ("gce_instance" OR "aws_ec2_instance")

Los valores del tipo de recurso supervisado en los registros se indexan. El uso de coincidencias de substring para ellos hace que las consultas sean más lentas.

Campos faltantes

Si usas un nombre de campo en una consulta y ese campo no aparece en una entrada de registro, entonces el campo es un campo faltante, indefinido o predeterminado:

  • Si el campo es parte de la carga útil de la entrada de registro (jsonPayload o protoPayload) o si está en una etiqueta de la sección labels de la entrada de registro, el campo es un campo faltante. El uso de un campo faltante no mostrará un error, pero todas las comparaciones que usan campos faltantes fallarán de forma silenciosa.

    Ejemplos: jsonPayload.nearest_store, protoPayload.name.nickname

  • Si el campo está definido en el tipo LogEntry, entonces, está predeterminado. Las comparaciones se realizan como si el campo estuviera presente y tuviera su valor predeterminado.

    Ejemplos: httpRequest.remoteIp, trace, operation.producer

  • De lo contrario, el campo está indefinido, que es un error que se detecta antes de que se use la consulta.

    Ejemplos: thud, operation.thud, textPayload.thud

Para comprobar si hay un campo faltante o predeterminado sin probar un valor particular en el campo, usa la comparación :*. Por ejemplo, la siguiente comparación se realiza de forma correcta si el campo operation.id está presente de modo explícito en una entrada de registro:

operation.id:*

Ten en cuenta el comportamiento de las siguientes consultas:

  • Cuando usas el operador booleano NOT en un campo faltante, el resultado es TRUE:

    # Returns TRUE
    NOT missingField=foo
    
  • Cuando usas el operador de comparación de desigualdad != en un campo faltante, el resultado es FALSE:

    # Returns FALSE
    missingField!=foo
    

Tipos de objetos y arreglos

Cada campo de entrada de registro puede contener un escalar, un objeto o un arreglo.

  • Un campo escalar almacena un valor único, como 174.4 o -1. Una string también se considera un escalar. Los campos que se pueden convertir en (o desde) una string, como Duration y Timestamp, también son tipos escalares.

  • Un tipo de objeto almacena una recopilación de valores con nombre, como el valor JSON siguiente:

    {"age": 24, "height": 67}
    

    Puedes hacer referencia a un valor dentro de un objeto. Por ejemplo, si jsonPayload.x contiene el valor anterior, entonces jsonPayload.x.age tendría el valor 24.

  • Un campo de arreglos almacena una lista de valores, todos del mismo tipo. Por ejemplo, un campo que contiene medidas podría tener el arreglo de números siguiente:

    {8.5, 9, 6}
    

    Cuando se realizan comparaciones y [FIELD_NAME] es un campo de arreglo, cada miembro del arreglo se compara con [VALUE], y los resultados se unen mediante el operador OR. Por ejemplo, si jsonPayload.shoeSize es un campo de arreglo que almacena {8.5, 9, 6}, la comparación siguiente:

    jsonPayload.shoeSize < 7
    

    es equivalente a esto:

    8.5 < 7 OR 9 < 7 OR 6 < 7
    

    En este ejemplo, la comparación en general se evalúa como exitosa.

Valores y conversiones

El primer paso a la hora de evaluar una comparación es convertir el valor del lado derecho al tipo del campo de entrada de registro. Los tipos de campos de escalares están permitidos en las comparaciones, junto con dos tipos adicionales cuyos valores se representan como strings: Duration y Timestamp. Para obtener una lista de tipos de escalares, consulta la lista de tipos de búfer de protocolo escalar. En la tabla siguiente, se explica qué valores se pueden convertir en los tipos de campo de registro:

Tipo de campo Valor de consulta permitido
bool

“Verdadero” o “falso” en mayúsculas o minúsculas. Ejemplos: “Verdadero”, “verdadero”.

bytes

Una string que contiene cualquier secuencia de bytes. Ejemplo: “\377\377”.

Duration

Una string que contiene un número decimal con firma seguido de una de las unidades “ns”, “us”, “m”, “s”, “m” o “h”. Las duraciones son precisas, se miden en nanosegundos. Ejemplo: “3.2s”.

enum

El nombre de un tipo de enumeración literal, con distinción de mayúsculas y minúsculas. Ejemplos: “WARNING”, que es un valor del tipo LogSeverity.

double

Cualquier número, sin un signo o con y una parte del exponente o las strings de valores especiales “-Infinity”, “Infinity” y “Nan” (en mayúscula o no). Ejemplos: “-3.2e-8”, “nan”.

intNN

Cualquier número entero con firma que no exceda el tamaño del tipo. Ejemplo: “-3”.

string

Cualquier string que contenga texto codificado en UTF-8 o ASCII de 7 bits. Las comillas incorporadas se deben escapar con una barra invertida.

Los valores de string deben estar entre comillas dobles para escapar los siguientes caracteres especiales:

  • Strings que comienzan con + (más), - (menos) o . (punto).

  • Strings con ~ (tilde), = (es igual a), () (paréntesis), : (dos puntos), > (mayor que), < (menor que), , (coma) o . (punto).

  • Cualquier secuencia de escape, por ejemplo, \t.

Timestamp

Una string en formato RFC 3339 o ISO 8601. Examples y coma; “2014-10-02T15&colon;01&colon;23.045Z” (RFC 3339), “2014-10-02” (ISO 8601). En las expresiones de consulta, las marcas de tiempo en formato RFC 3339 pueden especificar una zona horaria con “Z” o ±hh:mm. Las marcas de tiempo se representan con una exactitud de nanosegundos.

uintNN

Cualquier número entero sin firma que no exceda el tamaño del tipo. Ejemplo: “1234”.

Si falla un intento de conversión, también falla la comparación.

Cuando una conversión necesita una string, también puedes usar un número o un texto sin comillas si no contienen caracteres especiales como espacios y operadores. De manera similar, cuando una conversión necesita un número, puedes usar una string cuyo contenido sea un número.

Los tipos intNN y uintNN representan tipos de números enteros de varios tamaños, como int32 y uint64. Cuando escribes un valor para convertirlo en un tipo de número entero de 64 bits, debes escribir el valor como una string, por ejemplo “9223372036854775807”.

Tipos de campos de registro

A continuación, se muestra cómo se determina el tipo de un campo de entrada de registro:

  • Los campos de registro que se definen en un tipo LogEntry y en el tipo de componente son campos de búfer de protocolo. Los campos de búfer de protocolo tienen tipos explícitos.

  • Los campos de registro que forman parte de los objetos protoPayload también son campos de búfer de protocolo y tienen tipos explícitos. El nombre del tipo de búfer de protocolo se almacena en el campo "@type" de protoPayload. Para obtener más información, revisa la sección sobre la asignación de JSON.

  • Los campos de registro dentro de jsonPayload tienen tipos que se infieren del valor del campo cuando se recibe la entrada de registro:

    • Los campos cuyos valores son números sin comillas tienen el tipo double.
    • Los campos cuyos valores son true o false tienen el tipo bool.
    • Los campos cuyos valores son strings tienen el tipo string.

    Los números enteros largos (de 64 bits) se almacenan en campos de strings, porque no se pueden representar como valores double de manera exacta.

  • Los tipos Duration y Timestamp solo se reconocen en los campos de búfer de protocolo. En otros lugares, esos valores se almacenan en campos de strings.

Operadores de comparación

El significado de los operadores de igualdad (=, !=) y de desigualdad (<, <=, >, >=) depende del tipo del nombre del campo izquierdo subyacente.

  • Todos los tipos numéricos: La igualdad y la desigualdad tienen su significado normal para los números.
  • bool: La igualdad representa el mismo valor booleano. La desigualdad se define por true>false.
  • enum: La igualdad representa el mismo valor de enumeración. La desigualdad usa los valores numéricos subyacentes de los literales de enumeración.
  • Duration: La igualdad representa la misma duración. La desigualdad se basa en la duración. Ejemplo: como duraciones, "1s">"999ms".
  • Timestamp: La igualdad representa el mismo instante. Si a y b son valores Timestamp, a < b significa que a está antes que b.
  • bytes: Los operandos se comparan byte por byte, de izquierda a derecha.
  • string: Las comparaciones no distinguen entre mayúsculas o minúsculas. En particular, primero se normalizan ambos operandos mediante la normalización de NFKC_CF Unicode y, luego, usan comparaciones lexicográficas. Sin embargo, no se normalizan las búsquedas de expresiones regulares. Para obtener más información sobre la búsqueda de entradas de registro mediante expresiones regulares, lee Consulta y filtra entradas de registro mediante expresiones regulares.

El operador de substring (:) se puede aplicar a string y bytes, y se maneja como una igualdad, excepto que el operando de la derecha solo necesita ser igual a una parte del campo de la izquierda. Las coincidencias de substrings en los campos indexados no aprovechan los índices de registro.

Restricciones globales

Si la comparación consiste de un valor único, se denomina restricción global. Logging usa el operador has (:) para determinar si algún campo en una entrada de registro o su carga útil contiene la restricción global. Si es así, entonces, la comparación tiene éxito.

La consulta más simple escrita en términos de una restricción global es un valor único:

"The Cat in The Hat"

Puedes combinar restricciones globales mediante los operadores AND y OR para obtener una consulta más interesante. Por ejemplo, si deseas mostrar todas las entradas de registro que tienen un campo que contiene cat y un campo que contiene hat o bat, escribe la consulta del siguiente modo:

(cat AND (hat OR bat))

En este caso, existen tres restricciones globales: cat, hat y bat. Estas restricciones globales se aplican por separado y los resultados se combinan, como si la expresión se hubiera escrito sin paréntesis.

Una forma fácil de consultar tus registros en busca de un valor particular es mediante una restricción global. Por ejemplo, si buscas en tu registro de actividad entradas que contienen alguna mención de GCE_OPERATION_DONE, puedes usar la siguiente consulta:

    logName = "projects/my-project-id/logs/compute.googleapis.com%2Factivity_log" AND
    "GCE_OPERATION_DONE"

Si bien las restricciones globales son fáciles, pueden ser lentas. Para obtener más información, consulta Busca entradas de registro con rapidez en esta página.

Funciones

Puedes usar funciones integradas como restricciones globales en las consultas:
function = identifier ( [ argument { , argument } ] )

En el ejemplo anterior, argument es un valor, un nombre de campo o una expresión entre paréntesis. Las funciones se describen en las siguientes secciones.

log_id

La función log_id muestra entradas de registro que coinciden con el argumento [LOG_ID] determinado del campo logName:

  log_id([LOG_ID])

Por ejemplo, mediante la siguiente consulta, se muestran todas las entradas de registro con un [LOG_ID] cloudaudit.googleapis.com%2Factivity:

  log_id("cloudaudit.googleapis.com/activity")

sample

La función sample selecciona una fracción de la cantidad total de entradas de registro:

sample([FIELD], [FRACTION])

[FIELD] es el nombre de un campo en la entrada de registro, como logName o jsonPayload.a_field. El valor del campo determina si la entrada de registro está en la muestra. El tipo de campo debe ser una string o un valor numérico. Configurar [FIELD] como insertId es una buena opción, ya que cada entrada de registro tiene un valor diferente para ese campo.

[FRACTION] es la fracción de entradas de registro que tienen valores que [FIELD] debe incluir. Es un número mayor que 0.0 y menor o igual que 1.0. Por ejemplo, si especificas 0.01, entonces la muestra contiene un valor aproximado del uno por ciento de todas las entradas de registro que tienen valores para [FIELD]. Si [FRACTION] es 1, se eligen todas las entradas de registro que tienen valores para [FIELD].

Ejemplo: La siguiente consulta muestra el 25% de las entradas del registro syslog:

    logName = "projects/my-project/logs/syslog" AND sample(insertId, 0.25)

Detalles: Se usa un algoritmo determinista, en función de los hashes, para determinar si una entrada de registro se incluye o no en la muestra. La precisión del ejemplo resultante depende de la distribución de los valores de hash. Si los valores de hash no están distribuidos de manera uniforme, la muestra resultante se puede sesgar. En el peor de los casos, cuando [FIELD] siempre contiene el mismo valor, la muestra resultante contiene la [FRACTION] de todas las entradas de registro o ninguna de ellas.

Si [FIELD] aparece en una entrada de registro, sucede lo siguiente:

  • Se calcula un hash del valor.
  • El valor de hash, que es un número, se divide por el valor de hash máximo posible.
  • Si la fracción resultante es menor o igual que [FRACTION], la entrada de registro se incluye en la muestra; de lo contrario, se excluye de esta.

Si [FIELD] no aparece en una entrada de registro, sucede lo siguiente:

  • Si [FIELD] es parte de la carga útil de la entrada de registro o secciones labels, la entrada de registro no está seleccionada para la muestra, incluso si [FRACTION] es 1.
  • De lo contrario, a la entrada de registro se la trata como si [FIELD] estuviera en la entrada de registro y el valor de [FIELD] fuera el valor predeterminado. El tipo LogEntry determina el valor predeterminado. Para obtener más información sobre los campos faltantes y predeterminados, revisa Campos faltantes en esta página.

Para excluir las entradas de registro con campos predeterminados de la muestra, usa el operador de campo existente :*. La consulta siguiente genera una muestra del 1% de entradas de registro que proporcionaron un valor para field de forma explícita:

field:* AND sample(field, 0.01)

ip_in_net

La función ip_in_net determina si una dirección IP en una entrada de registro está contenida dentro una subred. Puedes usarlo para saber si una solicitud proviene de una fuente interna o externa. Por ejemplo:

ip_in_net([FIELD], [SUBNET])

[FIELD] es un campo con un valor de string en la entrada de registro que contiene un rango o una dirección IP. El campo puede repetirse; en ese caso, solo uno de los campos repetidos debe tener una dirección o un rango contenido en la subred.

[SUBNET] es una constante de string para una dirección IP o un rango. Es un error si [SUBNET] no es un rango o una dirección IP legal, como se describe más adelante en esta sección.

Ejemplo: La siguiente consulta prueba una dirección IP en la carga útil de entradas del registro my_log:

    logName = "projects/my_project/logs/my_log" AND
    ip_in_net(jsonPayload.realClientIP, "10.1.2.0/24")

Detalles: En caso de que en una entrada de registro faltara [FIELD], estuviera predeterminado o no contuviera una dirección IP o un rango legal, la función mostrará falso. Para obtener más información sobre los campos faltantes y predeterminados, revisa Campos faltantes en esta página.

A continuación, se incluyen algunos ejemplos de las direcciones IP y rangos admitidos:

  • IPv4: 10.1.2.3
  • Subred IPv4: 10.1.2.0/24
  • CIDR IPv6: 1234:5678:90ab:cdef:1234:5678:90ab:cdef
  • Subred CIDR IPv6: 1:2::/48

Busca por tiempo

En la interfaz, puedes establecer límites específicos para la fecha y la hora de las entradas de registro que se mostrarán. Por ejemplo, si agregas las siguientes condiciones a tu consulta, el Explorador de registros mostrará con exactitud las entradas de registro en el período indicado de 30 minutos y no podrás desplazarte fuera de esa fecha. intervalo:

timestamp >= "2016-11-29T23:00:00Z"
timestamp <= "2016-11-29T23:30:00Z"

Cuando escribes una consulta con una marca de tiempo, debes usar fechas y horas en el formato que se muestra arriba.

También puedes buscar entradas de registro mediante combinaciones de teclas de timestamp. Por ejemplo, puedes ingresar una fecha con un operador de comparación para obtener todas las entradas de registro que se produjeron después de un día determinado:

  timestamp > "2016-11-29"

Usa expresiones regulares

Puedes usar expresiones regulares a fin de compilar consultas y crear filtros para usar en los receptores, en las métricas y en donde sea que se usen los filtros de registro. Puedes usar expresiones regulares en el compilador de consultas y mediante la gcloud command-line tool.

Una expresión regular es una secuencia de caracteres que define una búsqueda. En el lenguaje de consulta, se usa la sintaxis RE2. Para obtener una explicación completa sobre la sintaxis RE2, ve a la Wiki de RE2 en GitHub.

Las consultas de expresiones regulares tienen las siguientes características:

  • Solo los campos del tipo string pueden coincidir con una expresión regular.

  • No se realiza la normalización de strings. Por ejemplo, kubernetes no se considera equivalente a KUBERNETES. Para obtener más información, consulta la sección Operadores de comparación.

  • Las consultas distinguen entre mayúsculas y minúsculas, y no están ancladas de forma predeterminada.

  • Los operadores booleanos se pueden usar entre varias expresiones regulares en el lado derecho del operador de comparación de expresiones regulares =~!~.

Una consulta de expresión regular tiene la siguiente estructura:

Si coincide con un patrón, se verá así:

jsonPayload.message =~ "regular expression pattern"

Si no coincide con un patrón, se verá así:

jsonPayload.message !~ "regular expression pattern"

=~ y !~ cambian la consulta a una consulta de expresión regular. El patrón con el que intentas realizar la coincidencia debe estar entre comillas dobles. Para consultar patrones que contengan comillas dobles, escápalas mediante el uso de una barra inversa.

Ejemplos de consultas de registros mediante expresiones regulares

Tipo de consulta Ejemplo
Consulta estándar sourceLocation.file =~ "foo"
Consulta mediante una búsqueda en la que no se distingue entre mayúsculas y minúsculas labels.subnetwork_name =~ "(?i)foo"
Consulta que contiene comillas jsonPayload.message =~ "field1=\"bar.*\""
Consulta mediante un valor booleano or labels.pod_name =~ "(foo|bar)"
Consulta mediante anclas logName =~ "/my%2Flog$"
Consulta que no coincide con un patrón labels.pod_name !~ "foo"
Consulta mediante un operador booleano labels.env =~ ("^prod.*server" OR "^staging.*server")