Divide las entradas de registro de auditoría

En este documento, se describe cómo Cloud Logging divide las entradas de registro de auditoría de gran tamaño y se proporciona orientación para volver a ensamblar estos registros de auditoría divididos.

Cuando una sola entrada de registro de auditoría supera el límite de tamaño, Cloud Logging divide esa entrada y distribuye los datos contenidos en el entrada de registro de auditoría original en varias entradas. Es posible que los usuarios deseen volver a ensamblar los registros de auditoría divididos, ya que las entradas de registro divididas individuales no contienen todos los campos del registro de auditoría original.

Reconoce las entradas de registro de auditoría dividida

Las entradas de registro de divisiones contienen información sobre la entrada original desde la cual se dividieron. Si una entrada de registro contiene un campo split y, luego, es el resultado de dividir una entrada de registro original más grande. El split el campo es LogSplit objeto que contiene la información necesaria para identificar el registro de divisiones relacionado de entradas de registro.

Cada entrada de registro de división contiene los siguientes campos:

• split.uid: Es un identificador único para el grupo de entradas de registro que se dividieron. de una entrada de registro original común. El valor de este campo es el mismo para todos los separadas divididas de la entrada de registro original.

• split.index: Es la posición de esta entrada en la serie de entradas de división. El La primera entrada de la división tiene el índice 0. split.index también se agrega a el campo LogEntry.insertId.

• split.totalSplits: Es la cantidad de entradas de registro en las que se dividió la entrada de registro original. El valor de este campo es el mismo para todas las entradas dividir de la entrada de registro original.

Cómo se divide una entrada de registro

Cuando se divide una entrada de registro de auditoría de gran tamaño, los campos se distribuyen entre las entradas de registro divididas resultantes de la siguiente manera:

• Todos los campos, excepto el protoPayload, se duplican en cada división entrada.

• Los siguientes subcampos protoPayload se pueden dividir en varias entradas:

  • protoPayload.metadata
  • protoPayload.request
  • protoPayload.response

• Todos los demás subcampos protoPayload se incluyen en todas las entradas de división.

• Para los subcampos protoPayload.metadata, protoPayload.request y protoPayload.response, los siguientes tipos de campos se pueden dividir en varias entradas:

  • Struct
  • Value
  • ListValue
  • string
  • Cualquier campo repetido, independientemente del tipo

Si un campo es miembro de un campo divisible, pero no es uno de los que se pueden dividir tipos de campo, solo estará presente en uno de los registros divididos.

Por ejemplo, un campo booleano del subcampo protoPayload.request solo puede en una entrada de registro dividida, pero un campo de cadena en protoPayload.request subcampo puede tener su contenido dividido en varias entradas de registro divididas.

Para ver un ejemplo de cómo se divide una entrada larga, consulta Ejemplo de división de entrada de registro.

Campos repetidos con muchos valores

Cuando el valor del campo protoPayload.metadata, protoPayload.request o protoPayload.response contiene una lista de valores repetidos, es posible que la lista se divida y se distribuya en varias entradas de registro divididas.

Por ejemplo, la lista de valores ["foo", "bar", "baz"] podría dividirse en 2 listas: ["foo", "ba"] y ["", "r", "baz"]. La primera lista es la entrada con el split.index de 0, y la segunda lista está en la entrada con split.index de 1 La segunda lista comienza con una cadena vacía para mantener las posiciones de los elementos en la lista y para indicar que los elementos en las mismas posiciones de las diferentes listas deben unirse. En el ejemplo, ba es el segundo elemento de lista en la entrada 0, y r es el segundo elemento de la lista en la entrada 1, por lo que se vuelven a combinar en el orden bar cuando se vuelve a reunir la lista original.

Campos grandes y no repetidos

Cuando los campos grandes y no repetidos de Struct y string se dividen, estos campos se manejan de la siguiente manera:

• Un campo string se divide a nivel de caracteres y no a nivel de bytes. Por lo tanto, los caracteres de varios bytes no se modifican.

• LogEntry.split.index controla el orden del contenido de los campos divididos y no repetidos.

Vuelve a ensamblar la entrada de registro dividida

Para volver a ensamblar un conjunto de registros divididos, completa los siguientes pasos:

1. Ordena el conjunto de registros de auditoría divididos por LogEntry.split.index de forma ascendente.

2. Crea una copia del primer registro dividido, donde LogEntry.split.index == 0. Esta copia es el comienzo del registro reensamblado.

3. Para las entradas de registro restantes, itera todos los campos divisibles de protoPayload y completa los siguientes pasos para cada campo:

   1. Si el campo ya existe en el registro reensamblado, agrega el contenido de ese campo en el registro reensamblado.

   2. Si el campo no existe en el registro reensamblado, cópialo en el registro reensamblado

      Cuando se dividen, los campos repetidos conservan el índice de sus elementos, por lo que puedes Aplica estos pasos a nivel del elemento cuando vuelvas a ensamblar un campo repetido.

4. Después de iterar a través de los campos divisibles, borra LogEntry.split de un registro reensamblado.

5. Quita el sufijo .0 de LogEntry.insert_id del registro reensamblado.

Consultas de muestra

Para encontrar todas las entradas de registro que se dividieron de la misma entrada de registro original, ejecuta la siguiente consulta en el Explorador de registros y reemplaza la variable UID por el valor deseado:

split.uid="UID"

Por ejemplo:

split.uid="abc123"

Para encontrar todas las entradas de registro que forman parte de cualquier división, ejecuta la siguiente consulta:

split:*

Filtra los registros de auditoría divididos

Puedes excluir todos los registros de auditoría divididos de una consulta con el siguiente filtro:

split.totalSplits = 0

También puedes incluir solo la primera entrada de un registro de auditoría dividido y excluir el resto de las entradas con el siguiente filtro:

split.index = 0

Ejemplo de división de entrada de registro

En el siguiente ejemplo, se muestra una entrada de registro de auditoría antes de que se divida en cuatro las entradas de registro. Las nuevas entradas muestran cómo se manejan los diferentes campos en la una operación de división.

Entrada de registro de auditoría de gran tamaño antes de la división

{
  "insertId": "567",
  "logName": "projects/1234/logs/cloudaudit.googleapis.com%2Fdata_access",
  "resource": {
    "type": "audited_resource"
  },
  "protoPayload": {
    "serviceName": "example.googleapis.com",
    "methodName": "google.cloud.example.ExampleMethod",
    "resourceName": "projects/1234/resources/123",
    "status": {
      "code": 0
    },
    "authenticationInfo": {
      "principalEmail": "user@example_company.com"
    },
    "authorizationInfo": [
      {
        "resource": "example.googleapis.com/projects/1234/resources/123",
        "permission": "examples.get",
        "granted": "true"
      }
    ],
    "request" {
      "boolField": true,
      "numberField": 123,
      "stringField": "Very long string that needs 2 log entries.",
      "structField": {
        "nestedNumberField": 1337,
        "nestedStringField": "Another long string that needs 2 log entries.",
      },
      "listField" [
        {"value": "short 1"},
        {"value": "Yet another long string."},
        {"value": "short 2"},
        {"value": "short 3"},
      ]
    }
  }
}

Entrada de registro de auditoría de gran tamaño después de la división

La entrada de registro original se divide en las siguientes entradas. Ten en cuenta que cada entrada Incluye el objeto split con un uid y un valor totalSplits de 4. Cada tiene un valor split.index de 0, 1, 2 o 3, que indica la de las entradas de registro divididas.

Entrada de registro de división, índice 0

Esta es la primera entrada de registro dividida, con un valor split.index de 0.

{
  "insertId": "567.0",
  "logName": "projects/1234/logs/cloudaudit.googleapis.com%2Fdata_access",
  "resource": {
    "type": "audited_resource"
  },
  "split": { 
    "uid": "789+2022-02-22T12:22:22.22+05:00",
    "index": 0,
    "totalSplits": 4,
  },
  "protoPayload": {
    // The following fields are included in all split entries
    "serviceName": "example.googleapis.com",
    "methodName": "google.cloud.example.ExampleMethod",
    "resourceName": "projects/1234/resources/123",
    "status": {
      "code": 0
    },
    "authenticationInfo": {  // small size; included in all split entries
      "principalEmail": "user@example_company.com"
    },
   // The following field is included in this split entry only.
   "authorizationInfo": [
      {
        "resource": "spanner.googleapis.com/projects/1234/datasets/123",
        "permission": "databases.read",
        "granted": "true"
      }
    ],
    // The following field is split across all the split entries
    "request" { 
      // boolField and numberField can only be in one split.
      "boolField": true,
      "numberField": 123,
      // Split with the next LogEntry.
      "stringField": "Very long string that ",
    }
  }
}

Entrada de registro de la división, índice 1

Esta es la siguiente entrada de registro de división, con un valor de split.index de 1.

{
  "insertId": "567.1",
  "logName": "projects/1234/logs/cloudaudit.googleapis.com%2Fdata_access",
  "resource": {
    "type": "audited_resource"
  },
  "split": { 
    "uid": "567+2022-02-22T12:22:22.22+05:00",
    "index": 1,
    "totalSplits": 4,
  },
  "protoPayload": { 
    "serviceName": "example.googleapis.com",
    "methodName": "google.cloud.example.ExampleMethod",
    "resourceName": "projects/1234/resources/123",
    "status": {
      "code": 0
    },
    "authenticationInfo": {
      "principalEmail": "user@example_company.com"
    },
    "request" { 
      // boolField and numberField aren't present
      // Continued from the previous entry.
      "stringField": "needs 2 log entries.",
      "structField": { 
        "nestedNumberField": 1337,
        // Split with the next LogEntry.
        "nestedStringField": "Another long string ",
      }
    }
  }
}

Entrada de registro dividida, índice 2

Esta es la siguiente entrada de registro de división, con un valor de split.index de 2.

{
  "insertId": "567.2",
  "logName": "projects/1234/logs/cloudaudit.googleapis.com%2Fdata_access",
  "resource": {
    "type": "audited_resource"
  },
  "split": { 
    "uid": "567+2022-02-22T12:22:22.22+05:00",
    "index": 2,
    "totalSplits": 4,
  },
  "protoPayload": { 
    "serviceName": "example.googleapis.com",
    "methodName": "google.cloud.example.ExampleMethod",
    "resourceName": "projects/1234/resources/123",
    "status": {
      "code": 0
    },
    "authenticationInfo": {
      "principalEmail": "user@example_company.com"
    },
    request { 
      "structField": { 
        // Continued from the previous entry.
        "nestedStringField": "that needs 2 log entries.",
      }
      "listField" [ 
         {"value": "short 1"},
         {"value": "Yet another "}, // Split with the next LogEntry.
        // Missing two values, split with the next LogEntry.
      ]
    }
  }
}

Entrada de registro de división, índice 3

Esta es la entrada de registro de división final, con un valor de split.index de 3.

{
  "insertId": "567.3",
  "logName": "projects/1234/logs/cloudaudit.googleapis.com%2Fdata_access",
  "resource": {
    "type": "audited_resource"
  },
  "split": { 
    "uid": "567+2022-02-22T12:22:22.22+05:00",
    "index": 3,
    "totalSplits": 4,
  },
  "protoPayload": { 
    "serviceName": "example.googleapis.com",
    "methodName": "google.cloud.example.ExampleMethod",
    "resourceName": "projects/1234/resources/123",
    "status": {
      "code": 0
    },
    "authenticationInfo": {
      "principalEmail": "user@example_company.com"
    },
    "request" { 
      "listField" [ 
        {}, // Padding to ensure correct positioning of elements in split repeated fields.
         {"value": "long string."}, // Continuation of the second repeated field.
         {"value": "short 2"},
         {"value": "short 3"},
      ]
    }
  }
}