Raccogliere gli audit log di Slack

Supportato in:

Questa guida spiega come importare gli audit log di Slack in Google Security Operations utilizzando Google Cloud Run Functions o Amazon S3 con AWS Lambda.

Prima di iniziare

Assicurati di soddisfare i seguenti prerequisiti:

  • Istanza Google SecOps.
  • Piano Slack Enterprise Grid con accesso Proprietario dell'organizzazione o Amministratore.
  • Accesso con privilegi a:
    • Google Cloud (per l'opzione 1: Cloud Run Functions e Cloud Scheduler) o
    • AWS (per l'opzione 2: S3, IAM, Lambda, EventBridge).

Prerequisiti per la raccolta degli audit log di Slack (ID app, token OAuth, ID organizzazione)

L'API Audit Logs di Slack richiede un token OAuth utente con l'ambito auditlogs:read. Questo token deve essere ottenuto installando un'app a livello di organizzazione Enterprise Grid, non a livello di workspace.

Creare l'app Slack per gli audit log

  1. Accedi alla Console di amministrazione di Slack con un account Proprietario dell'organizzazione Enterprise Grid o Amministratore.
  2. Vai alla pagina https://api.slack.com/apps e fai clic su Crea nuova app > Da zero.
  3. Fornisci i seguenti dettagli di configurazione:
    • Nome app: inserisci un nome descrittivo (ad esempio Google SecOps Audit Integration).
    • Scegli un workspace in cui sviluppare la tua app: seleziona il tuo workspace Slack di sviluppo (qualsiasi workspace dell'organizzazione).
  4. Fai clic su Crea app.

Configurare gli ambiti OAuth

  1. Vai a OAuth e autorizzazioni nella barra laterale sinistra.
  2. Scorri verso il basso fino alla sezione Ambiti.
  3. In Ambiti dei token utente (NON Ambiti dei token bot), fai clic su Aggiungi un ambito OAuth.
  4. Aggiungi l'ambito: auditlogs:read.

Abilitare la distribuzione pubblica

  1. Vai a Gestisci distribuzione nella barra laterale sinistra.
  2. In Condividi la tua app con altri workspace, assicurati che tutte e quattro le sezioni abbiano segni di spunta verdi:
    • Rimuovi informazioni codificate
    • Attiva la distribuzione pubblica
    • Imposta un URL di reindirizzamento
    • Aggiungi un ambito OAuth
  3. Fai clic su Attiva la distribuzione pubblica.

Installare l'app nell'organizzazione Enterprise Grid

  1. Vai a OAuth e autorizzazioni nella barra laterale sinistra.
  2. Fai clic su Installa nell'organizzazione (NON "Installa nel workspace").

IMPORTANTE: controlla il menu a discesa in alto a destra della schermata di installazione per verificare che l'installazione venga eseguita nell'organizzazione Enterprise, non in un singolo workspace.

  1. Esamina le autorizzazioni richieste e fai clic su Consenti.
  2. Al termine dell'autorizzazione, verrai reindirizzato alla pagina OAuth e autorizzazioni.

Recuperare le credenziali

  1. In Token OAuth per il tuo workspace, individua il token OAuth utente.
  2. Copia e salva in modo sicuro il token che inizia con xoxp- (ad esempio, xoxp-1234567890-0987654321-1234567890-abc123def456).

Importante: questo è il tuo SLACK_ADMIN_TOKEN per la funzione Lambda o Cloud Run. Conservalo in modo sicuro.

  1. Prendi nota del tuo ID organizzazione:
    • Vai alla Console di amministrazione di Slack.
    • Vai a Impostazioni e autorizzazioni > Impostazioni dell'organizzazione.
    • Copia l'ID organizzazione.

Opzione 1: configurare l'esportazione degli audit log di Slack utilizzando Google Cloud Run Functions

Questa opzione utilizza Google Cloud Run Functions e Cloud Scheduler per raccogliere gli audit log di Slack e importarli direttamente in Google SecOps.

Configurare la directory

  1. Crea una nuova directory sulla macchina locale per il deployment della funzione Cloud Run.
  2. Scarica i seguenti file dal repository GitHub ingestion-scripts di Chronicle:
    • Dalla cartella slack, scarica:
      • .env.yml
      • main.py
      • requirements.txt
    • Dalla radice del repository, scarica l'intera directory common con tutti i relativi file:
      • common/__init__.py
      • common/auth.py
      • common/env_constants.py
      • common/ingest.py
      • common/status.py
      • common/utils.py
  3. Inserisci tutti i file scaricati nella directory di deployment.

La struttura di directory dovrebbe essere simile alla seguente:

deployment_directory/
├─common/
│ ├─__init__.py
│ ├─auth.py
│ ├─env_constants.py
│ ├─ingest.py
│ ├─status.py
│ └─utils.py
├─.env.yml
├─main.py
└─requirements.txt

Creare secret in Google Secret Manager

  1. Nella console Google Cloud, vai a Sicurezza > Secret Manager.
  2. Fai clic su Crea secret.
  3. Fornisci i seguenti dettagli di configurazione per il service account Chronicle:
    • Nome: inserisci chronicle-service-account.
    • Valore del secret: incolla i contenuti del file JSON di autenticazione dell'importazione di Google SecOps.
  4. Fai clic su Crea secret.
  5. Copia il nome della risorsa secret nel formato: projects/<PROJECT_ID>/secrets/chronicle-service-account/versions/latest.
  6. Fai di nuovo clic su Crea secret per creare un secondo secret.
  7. Fornisci i seguenti dettagli di configurazione per il token Slack:
    • Nome: inserisci slack-admin-token.
    • Valore del secret: incolla il token OAuth utente di Slack (che inizia con xoxp-).
  8. Fai clic su Crea secret.
  9. Copia il nome della risorsa secret nel formato: projects/<PROJECT_ID>/secrets/slack-admin-token/versions/latest.

Impostare le variabili di ambiente runtime richieste

  1. Apri il file .env.yml nella directory di deployment.
  2. Configura le variabili di ambiente con i tuoi valori:
CHRONICLE_CUSTOMER_ID: "<your-chronicle-customer-id>"
CHRONICLE_REGION: us
CHRONICLE_SERVICE_ACCOUNT: "projects/<PROJECT_ID>/secrets/chronicle-service-account/versions/latest"
CHRONICLE_NAMESPACE: ""
POLL_INTERVAL: "5"
SLACK_ADMIN_TOKEN: "projects/<PROJECT_ID>/secrets/slack-admin-token/versions/latest"

Sostituisci quanto segue:

  • <your-chronicle-customer-id>: il tuo ID cliente Google SecOps.
  • <PROJECT_ID>: l'ID del tuo progetto Google Cloud.
  • CHRONICLE_REGION: imposta la regione Google SecOps. Valori validi: us, asia-northeast1, asia-south1, asia-southeast1, australia-southeast1, europe, europe-west2, europe-west3, europe-west6, europe-west9, europe-west12, me-central1, me-central2, me-west1, northamerica-northeast2, southamerica-east1.
  • POLL_INTERVAL: intervallo di frequenza (in minuti) con cui viene eseguita la funzione. Questa durata deve essere uguale all'intervallo del job Cloud Scheduler.
  1. Salva il file .env.yml.

Eseguire il deployment della funzione Cloud Run

  1. Apri un terminale o Cloud Shell nella Google Cloud Console.
  2. Vai alla directory di deployment:
cd /path/to/deployment_directory
  1. Esegui il comando seguente per eseguire il deployment della funzione Cloud Run:
gcloud functions deploy slack-audit-to-chronicle \
  --entry-point main \
  --trigger-http \
  --runtime python39 \
  --env-vars-file .env.yml \
  --timeout 300s \
  --memory 512MB \
  --service-account <SERVICE_ACCOUNT_EMAIL>

Sostituisci <SERVICE_ACCOUNT_EMAIL> con l'indirizzo email del account di servizio che vuoi che la funzione Cloud Run utilizzi.

  1. Attendi il completamento del deployment.
  2. Una volta eseguito il deployment, prendi nota dell'URL della funzione nell'output.

Configurare Cloud Scheduler

  1. Nella console Google Cloud, vai a Cloud Scheduler > Crea job.
  2. Fornisci i seguenti dettagli di configurazione:
    • Nome: inserisci slack-audit-scheduler.
    • Regione: seleziona la stessa regione in cui hai eseguito il deployment della funzione Cloud Run.
    • Frequenza: inserisci */5 * * * * (viene eseguito ogni 5 minuti, in corrispondenza del valore POLL_INTERVAL).
    • Fuso orario: seleziona UTC.
    • Tipo di target: seleziona HTTP.
    • URL: inserisci l'URL della funzione Cloud Run dall'output del deployment.
    • Metodo HTTP: seleziona POST.
    • Intestazione di autenticazione: seleziona Aggiungi token OIDC.
    • Service account: seleziona lo stesso account di servizio utilizzato per la funzione Cloud Run.
  3. Fai clic su Crea.

Opzione 2: configurare l'esportazione degli audit log di Slack utilizzando AWS S3

Questa opzione utilizza AWS Lambda per raccogliere gli audit log di Slack e archiviarli in S3, quindi configura un feed Google SecOps per importare i log.

Configurare il bucket AWS S3 e IAM per Google SecOps

  1. Crea un bucket Amazon S3 seguendo questa guida utente: Creare un bucket
  2. Salva il nome e la regione del bucket per riferimento futuro (ad esempio, slack-audit-logs).
  3. Crea un utente seguendo questa guida utente: Creare un utente IAM.
  4. Seleziona l'utente creato.
  5. Seleziona la scheda Credenziali di sicurezza.
  6. Fai clic su Crea chiave di accesso nella sezione Chiavi di accesso.
  7. Seleziona Servizio di terze parti come Caso d'uso.
  8. Fai clic su Avanti.
  9. (Facoltativo) Aggiungi un tag di descrizione.
  10. Fai clic su Crea chiave di accesso.
  11. Fai clic su Scarica file .csv per salvare la chiave di accesso e la chiave di accesso secret per riferimento futuro.
  12. Fai clic su Fine.
  13. Seleziona la scheda Autorizzazioni.
  14. Fai clic su Aggiungi autorizzazioni nella sezione Policy di autorizzazione.
  15. Seleziona Aggiungi autorizzazioni.
  16. Seleziona Collega policy direttamente.
  17. Cerca la policy AmazonS3FullAccess.
  18. Seleziona la policy.
  19. Fai clic su Avanti.
  20. Fai clic su Aggiungi autorizzazioni.

Configurare la policy e il ruolo IAM per i caricamenti S3

  1. Nella console AWS, vai a IAM > Policy > Crea policy > Scheda JSON.
  2. Copia e incolla la policy riportata di seguito.
  3. JSON della policy (sostituisci slack-audit-logs se hai inserito un nome del bucket diverso):
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowPutObjects",
      "Effect": "Allow",
      "Action": "s3:PutObject",
      "Resource": "arn:aws:s3:::slack-audit-logs/*"
    },
    {
      "Sid": "AllowGetStateObject",
      "Effect": "Allow",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::slack-audit-logs/slack/audit/state.json"
    }
  ]
}
  1. Fai clic su Avanti.
  2. Inserisci il nome della policy SlackAuditS3Policy.
  3. Fai clic su Crea policy.
  4. Vai a IAM > Ruoli > Crea ruolo > Servizio AWS > Lambda.
  5. Collega la policy appena creata SlackAuditS3Policy.
  6. Assegna al ruolo il nome SlackAuditToS3Role e fai clic su Crea ruolo.

Creare la funzione Lambda

  1. Nella console AWS, vai a Lambda > Funzioni > Crea funzione.
  2. Fai clic su Crea da zero.
  3. Fornisci i seguenti dettagli di configurazione:
Impostazione Valore
Nome slack_audit_to_s3
Tempo di esecuzione Python 3.13
Architettura x86_64
Ruolo di esecuzione SlackAuditToS3Role
  1. Fai clic su Crea funzione.
  2. Dopo aver creato la funzione, apri la scheda Codice, elimina lo stub e incolla il codice riportato di seguito (slack_audit_to_s3.py).
#!/usr/bin/env python3
# Lambda: Pull Slack Audit Logs (Enterprise Grid) to S3 (JSONL format)

import os, json, time, urllib.parse
from urllib.request import Request, urlopen
from urllib.error import HTTPError, URLError
import boto3

BASE_URL = "https://api.slack.com/audit/v1/logs"

TOKEN        = os.environ["SLACK_AUDIT_TOKEN"]  # org-level user token with auditlogs:read
BUCKET       = os.environ["S3_BUCKET"]
PREFIX       = os.environ.get("S3_PREFIX", "slack/audit/")
STATE_KEY    = os.environ.get("STATE_KEY", "slack/audit/state.json")
LIMIT        = int(os.environ.get("LIMIT", "200"))             # Slack recommends <= 200
MAX_PAGES    = int(os.environ.get("MAX_PAGES", "20"))
LOOKBACK_SEC = int(os.environ.get("LOOKBACK_SECONDS", "3600")) # First-run window
HTTP_TIMEOUT = int(os.environ.get("HTTP_TIMEOUT", "60"))
HTTP_RETRIES = int(os.environ.get("HTTP_RETRIES", "3"))
RETRY_AFTER_DEFAULT = int(os.environ.get("RETRY_AFTER_DEFAULT", "2"))
# Optional server-side filters (comma-separated 'action' values), empty means no filter
ACTIONS      = os.environ.get("ACTIONS", "").strip()

s3 = boto3.client("s3")


def _get_state() -> dict:
    try:
        obj = s3.get_object(Bucket=BUCKET, Key=STATE_KEY)
        st = json.loads(obj["Body"].read() or b"{}")
        return {"cursor": st.get("cursor")}
    except Exception:
        return {"cursor": None}


def _put_state(state: dict) -> None:
    body = json.dumps(state, separators=(",", ":")).encode("utf-8")
    s3.put_object(Bucket=BUCKET, Key=STATE_KEY, Body=body, ContentType="application/json")


def _http_get(params: dict) -> dict:
    qs  = urllib.parse.urlencode(params, doseq=True)
    url = f"{BASE_URL}?{qs}" if qs else BASE_URL
    req = Request(url, method="GET")
    req.add_header("Authorization", f"Bearer {TOKEN}")
    req.add_header("Accept", "application/json")

    attempt = 0
    while True:
        try:
            with urlopen(req, timeout=HTTP_TIMEOUT) as r:
                return json.loads(r.read().decode("utf-8"))
        except HTTPError as e:
            # Respect Retry-After on 429/5xx
            if e.code in (429, 500, 502, 503, 504) and attempt < HTTP_RETRIES:
                retry_after = 0
                try:
                    retry_after = int(e.headers.get("Retry-After", RETRY_AFTER_DEFAULT))
                except Exception:
                    retry_after = RETRY_AFTER_DEFAULT
                time.sleep(max(1, retry_after))
                attempt += 1
                continue
            # Re-raise other HTTP errors
            raise
        except URLError:
            if attempt < HTTP_RETRIES:
                time.sleep(RETRY_AFTER_DEFAULT)
                attempt += 1
                continue
            raise


def _write_page(data: dict, page_idx: int) -> str:
    """
    Extract entries from Slack API response and write as JSONL (one event per line).
    Chronicle requires newline-delimited JSON, not a JSON array.
    """
    entries = data.get("entries") or []
    
    if not entries:
        # No entries to write, skip file creation
        return None
    
    # Convert each entry to a single-line JSON string
    lines = [json.dumps(entry, separators=(",", ":")) for entry in entries]
    
    # Join with newlines to create JSONL format
    body = "\n".join(lines).encode("utf-8")
    
    # Write to S3
    ts  = time.strftime("%Y/%m/%d/%H%M%S", time.gmtime())
    key = f"{PREFIX}{ts}-slack-audit-p{page_idx:05d}.json"
    s3.put_object(Bucket=BUCKET, Key=key, Body=body, ContentType="application/json")
    
    return key


def lambda_handler(event=None, context=None):
    state  = _get_state()
    cursor = state.get("cursor")

    params = {"limit": LIMIT}
    if ACTIONS:
        params["action"] = [a.strip() for a in ACTIONS.split(",") if a.strip()]
    if cursor:
        params["cursor"] = cursor
    else:
        # First run (or reset): fetch a recent window by time
        params["oldest"] = int(time.time()) - LOOKBACK_SEC

    pages = 0
    total = 0
    last_cursor = None

    while pages < MAX_PAGES:
        data = _http_get(params)
        
        # Write entries in JSONL format
        written_key = _write_page(data, pages)

        entries = data.get("entries") or []
        total += len(entries)

        # Cursor for next page
        meta = data.get("response_metadata") or {}
        next_cursor = meta.get("next_cursor") or data.get("next_cursor")
        if next_cursor:
            params = {"limit": LIMIT, "cursor": next_cursor}
            if ACTIONS:
                params["action"] = [a.strip() for a in ACTIONS.split(",") if a.strip()]
            last_cursor = next_cursor
            pages += 1
            continue
        break

    if last_cursor:
        _put_state({"cursor": last_cursor})

    return {"ok": True, "pages": pages + (1 if total or last_cursor else 0), "entries": total, "cursor": last_cursor}


if __name__ == "__main__":
    print(lambda_handler())

  1. Vai a Configurazione > Variabili di ambiente > Modifica > Aggiungi variabile di ambiente.
  2. Inserisci le variabili di ambiente riportate di seguito, sostituendo i valori con i tuoi.

Variabili di ambiente

Chiave Valore di esempio
S3_BUCKET slack-audit-logs
S3_PREFIX slack/audit/
STATE_KEY slack/audit/state.json
SLACK_AUDIT_TOKEN xoxp-*** (token utente a livello di organizzazione con auditlogs:read)
LIMIT 200
MAX_PAGES 20
LOOKBACK_SECONDS 3600
HTTP_TIMEOUT 60
HTTP_RETRIES 3
RETRY_AFTER_DEFAULT 2
ACTIONS (facoltativo, CSV) user_login,app_installed
  1. Fai clic su Salva.
  2. Seleziona la scheda Configurazione.
  3. Nel riquadro Configurazione generale , fai clic su Modifica.
  4. Modifica Timeout in 5 minuti (300 secondi) e fai clic su Salva.

Creare una pianificazione EventBridge

  1. Vai a Amazon EventBridge > Scheduler > Crea pianificazione.
  2. Fornisci i seguenti dettagli di configurazione:
    • Nome: inserisci slack-audit-1h.
    • Pianificazione ricorrente: seleziona Pianificazione basata sulla frequenza.
    • Espressione di frequenza: inserisci 1 ore.
    • Finestra di tempo flessibile: seleziona Disattivata.
  3. Fai clic su Avanti.
  4. Seleziona Target:
    • API di destinazione: seleziona Richiama AWS Lambda.
    • Funzione Lambda: seleziona slack_audit_to_s3.
  5. Fai clic su Avanti.
  6. Fai clic su Avanti (salta le impostazioni facoltative).
  7. Esamina e fai clic su Crea pianificazione.

(Facoltativo) Creare un utente e chiavi IAM di sola lettura per Google SecOps

  1. Vai a Console AWS > IAM > Utenti > Crea utente.
  2. Fornisci i seguenti dettagli di configurazione:
    • Nome utente: inserisci secops-reader.
    • Tipo di accesso: seleziona Accesso programmatico.
  3. Fai clic su Avanti.
  4. Seleziona Collega policy direttamente.
  5. Fai clic su Crea policy.
  6. Nella scheda JSON, incolla:
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject"],
      "Resource": "arn:aws:s3:::slack-audit-logs/*"
    },
    {
      "Effect": "Allow",
      "Action": ["s3:ListBucket"],
      "Resource": "arn:aws:s3:::slack-audit-logs"
    }
  ]
}
  1. Fai clic su Avanti.
  2. Inserisci il nome della policy secops-reader-policy.
  3. Fai clic su Crea policy.
  4. Torna alla pagina di creazione dell'utente, aggiorna l'elenco delle policy e seleziona secops-reader-policy.
  5. Fai clic su Avanti.
  6. Fai clic su Crea utente.
  7. Seleziona l'utente creato secops-reader.
  8. Vai a Credenziali di sicurezza > Chiavi di accesso > Crea chiave di accesso.
  9. Seleziona Servizio di terze parti.
  10. Fai clic su Avanti.
  11. Fai clic su Crea chiave di accesso.
  12. Fai clic su Scarica file .csv per salvare le credenziali.

Configurare un feed in Google SecOps per importare gli audit log di Slack

  1. Vai a Impostazioni SIEM > Feed.
  2. Fai clic su Aggiungi nuovo.
  3. Nel campo Nome feed, inserisci un nome per il feed (ad esempio, Slack Audit Logs).
  4. Seleziona Amazon S3 V2 come Tipo di origine.
  5. Seleziona Audit di Slack come Tipo di log.
  6. Fai clic su Avanti.
  7. Specifica i valori per i seguenti parametri di input:
    • URI S3: s3://slack-audit-logs/slack/audit/
    • Opzioni di eliminazione dell'origine: seleziona l'opzione di eliminazione in base alle tue preferenze.
    • Età massima del file: includi i file modificati negli ultimi giorni. Il valore predefinito è 180 giorni.
    • ID chiave di accesso: chiave di accesso utente con accesso al bucket S3 (da secops-reader).
    • Chiave di accesso secret: chiave secret utente con accesso al bucket S3 (da secops-reader).
    • Spazio dei nomi dell'asset: lo spazio dei nomi dell'asset.
    • Etichette di importazione: l'etichetta applicata agli eventi di questo feed.
  8. Fai clic su Avanti.
  9. Esamina la nuova configurazione del feed nella schermata Finalizza, quindi fai clic su Invia.

Tabella di mappatura UDM

Campo log Mappatura UDM Funzione logica
action metadata.product_event_type Mappato direttamente dal campo action nel log non elaborato.
actor.type principal.labels.value Mappato direttamente dal campo actor.type, con l'aggiunta della chiave actor.type.
actor.user.email principal.user.email_addresses Mappato direttamente dal campo actor.user.email.
actor.user.id principal.user.product_object_id Mappato direttamente dal campo actor.user.id.
actor.user.id principal.user.userid Mappato direttamente dal campo actor.user.id.
actor.user.name principal.user.user_display_name Mappato direttamente dal campo actor.user.name.
actor.user.team principal.user.group_identifiers Mappato direttamente dal campo actor.user.team.
context.ip_address principal.ip Mappato direttamente dal campo context.ip_address.
context.location.domain about.resource.attribute.labels.value Mappato direttamente dal campo context.location.domain, con l'aggiunta della chiave context.location.domain.
context.location.id about.resource.id Mappato direttamente dal campo context.location.id.
context.location.name about.resource.name Mappato direttamente dal campo context.location.name.
context.location.name about.resource.attribute.labels.value Mappato direttamente dal campo context.location.name, con l'aggiunta della chiave context.location.name.
context.location.type about.resource.resource_subtype Mappato direttamente dal campo context.location.type.
context.session_id network.session_id Mappato direttamente dal campo context.session_id.
context.ua network.http.user_agent Mappato direttamente dal campo context.ua.
context.ua network.http.parsed_user_agent Informazioni sull'user agent analizzate derivate dal campo context.ua utilizzando il filtro parseduseragent.
country principal.location.country_or_region Mappato direttamente dal campo country.
date_create metadata.event_timestamp.seconds Il timestamp dell'epoca dal campo date_create viene convertito in un oggetto timestamp.
details.inviter.email target.user.email_addresses Mappato direttamente dal campo details.inviter.email.
details.inviter.id target.user.product_object_id Mappato direttamente dal campo details.inviter.id.
details.inviter.name target.user.user_display_name Mappato direttamente dal campo details.inviter.name.
details.inviter.team target.user.group_identifiers Mappato direttamente dal campo details.inviter.team.
details.reason security_result.description Mappato direttamente dal campo details.reason o, se si tratta di un array, concatenato con virgole.
details.type about.resource.attribute.labels.value Mappato direttamente dal campo details.type, con l'aggiunta della chiave details.type.
details.type security_result.summary Mappato direttamente dal campo details.type.
entity.app.id target.resource.id Mappato direttamente dal campo entity.app.id.
entity.app.name target.resource.name Mappato direttamente dal campo entity.app.name.
entity.channel.id target.resource.id Mappato direttamente dal campo entity.channel.id.
entity.channel.name target.resource.name Mappato direttamente dal campo entity.channel.name.
entity.channel.privacy target.resource.attribute.labels.value Mappato direttamente dal campo entity.channel.privacy, con l'aggiunta della chiave entity.channel.privacy.
entity.file.filetype target.resource.attribute.labels.value Mappato direttamente dal campo entity.file.filetype, con l'aggiunta della chiave entity.file.filetype.
entity.file.id target.resource.id Mappato direttamente dal campo entity.file.id.
entity.file.name target.resource.name Mappato direttamente dal campo entity.file.name.
entity.file.title target.resource.attribute.labels.value Mappato direttamente dal campo entity.file.title, con l'aggiunta della chiave entity.file.title.
entity.huddle.date_end about.resource.attribute.labels.value Mappato direttamente dal campo entity.huddle.date_end, con l'aggiunta della chiave entity.huddle.date_end.
entity.huddle.date_start about.resource.attribute.labels.value Mappato direttamente dal campo entity.huddle.date_start, con l'aggiunta della chiave entity.huddle.date_start.
entity.huddle.id about.resource.attribute.labels.value Mappato direttamente dal campo entity.huddle.id, con l'aggiunta della chiave entity.huddle.id.
entity.huddle.participants.0 about.resource.attribute.labels.value Mappato direttamente dal campo entity.huddle.participants.0, con l'aggiunta della chiave entity.huddle.participants.0.
entity.huddle.participants.1 about.resource.attribute.labels.value Mappato direttamente dal campo entity.huddle.participants.1, con l'aggiunta della chiave entity.huddle.participants.1.
entity.type target.resource.resource_subtype Mappato direttamente dal campo entity.type.
entity.user.email target.user.email_addresses Mappato direttamente dal campo entity.user.email.
entity.user.id target.user.product_object_id Mappato direttamente dal campo entity.user.id.
entity.user.name target.user.user_display_name Mappato direttamente dal campo entity.user.name.
entity.user.team target.user.group_identifiers Mappato direttamente dal campo entity.user.team.
entity.workflow.id target.resource.id Mappato direttamente dal campo entity.workflow.id.
entity.workflow.name target.resource.name Mappato direttamente dal campo entity.workflow.name.
id metadata.product_log_id Mappato direttamente dal campo id.
ip principal.ip Mappato direttamente dal campo ip. Determinato dalla logica basata sul campo action. Il valore predefinito è USER_COMMUNICATION, ma cambia in altri valori come USER_CREATION, USER_LOGIN, USER_LOGOUT, USER_RESOURCE_ACCESS, USER_RESOURCE_UPDATE_PERMISSIONS, o USER_CHANGE_PERMISSIONS in base al valore di action. Codificato come "SLACK_AUDIT". Impostato su "Enterprise Grid" se date_create esiste, altrimenti impostato su "Audit Logs" se user_id esiste. Codificato come "Slack". Codificato come "REMOTE". Impostato su "SSO" se action contiene "user_login" or "user_logout". In caso contrario, impostato su "MACHINE". Non mappato negli esempi forniti. Il valore predefinito è "ALLOW", ma viene impostato su "BLOCK" se action è "user_login_failed". Impostato su "Slack" se date_create esiste, altrimenti impostato su "SLACK" se user_id esiste.
user_agent network.http.user_agent Mappato direttamente dal campo user_agent.
user_id principal.user.product_object_id Mappato direttamente dal campo user_id.
username principal.user.product_object_id Mappato direttamente dal campo username.

Hai bisogno di ulteriore assistenza? Ricevi risposte dai membri della community e dai professionisti di Google SecOps.