Raccogliere i log di controllo di Slack

Supportato in:

Google secops SIEM

Questa guida spiega come importare i log di controllo 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 come Proprietario dell'organizzazione o Amministratore.
Accesso privilegiato a:
- Google Cloud (per l'opzione 1: Cloud Run Functions e Cloud Scheduler) oppure
- AWS (per l'opzione 2: S3, IAM, Lambda, EventBridge).

Prerequisiti per la raccolta dei log di controllo di Slack (ID app, token OAuth, ID organizzazione)

L'API Slack Audit Logs 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 spazio di lavoro.

Creare l'app Slack per Audit Logs

Accedi alla console di amministrazione di Slack con un account proprietario dell'organizzazione Enterprise Grid o amministratore.
Vai su https://api.slack.com/apps e fai clic su Crea nuova app > Da zero.
Fornisci i seguenti dettagli di configurazione:
- Nome app: inserisci un nome descrittivo (ad esempio, Google SecOps Audit Integration).
- Scegli un workspace in cui sviluppare l'app: seleziona il tuo workspace di sviluppo di Slack (qualsiasi workspace dell'organizzazione).
Fai clic su Crea app.

Configura gli ambiti OAuth

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

Attivare la distribuzione pubblica

Vai a Gestisci distribuzione nella barra laterale sinistra.
In Condividi la tua app con altri spazi di lavoro, assicurati che tutte e quattro le sezioni siano contrassegnate da un segno di spunta verde:
- Rimuovere le informazioni codificate
- Attiva la distribuzione pubblica
- Impostare un URL di reindirizzamento
- Aggiungere un ambito OAuth
Fai clic su Attiva distribuzione pubblica.

Installare l'app nell'organizzazione Enterprise Grid

Vai a OAuth e autorizzazioni nella barra laterale sinistra.
Fai clic su Installa nell'organizzazione (NON su "Installa in Workspace").

Importante: controlla il menu a discesa in alto a destra della schermata di installazione per verificare di eseguire l'installazione nell'organizzazione Enterprise, non in un singolo spazio di lavoro.
Controlla le autorizzazioni richieste e fai clic su Consenti.
Al termine dell'autorizzazione, tornerai alla pagina OAuth e autorizzazioni.

Recuperare le credenziali

In Token OAuth per il tuo spazio di lavoro, individua il token OAuth utente.
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.
Prendi nota dell'ID organizzazione:
1. Vai alla Console di amministrazione di Slack.
2. Vai a Impostazioni e autorizzazioni > Impostazioni dell'organizzazione.
3. Copia l'ID organizzazione.

Opzione 1: configura l'esportazione dei log di controllo di Slack utilizzando Google Cloud Run Functions

Questa opzione utilizza Google Cloud Run Functions e Cloud Scheduler per raccogliere i log di controllo di Slack e inserirli direttamente in Google SecOps.

Configurare la directory

Crea una nuova directory sulla macchina locale per il deployment della funzione Cloud Run.
Scarica i seguenti file dal repository GitHub di Chronicle ingestion-scripts:
- 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
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

Crea secret in Google Secret Manager

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

Impostazione delle variabili di ambiente runtime richieste

Apri il file .env.yml nella directory di deployment.
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: impostalo sulla tua 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 corrispondere all'intervallo del job Cloud Scheduler.
Salva il file .env.yml.

Deployment della funzione Cloud Run

Apri un terminale o Cloud Shell nella console Google Cloud .
Vai alla directory di deployment:
```
cd /path/to/deployment_directory
```
Esegui questo comando 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 utilizzi la tua funzione Cloud Run.
  
  Nota :il account di servizio che esegue la funzione Cloud Run deve disporre dei ruoli Cloud Functions Invoker (roles/cloudfunctions.invoker) e Secret Manager Secret Accessor (roles/secretmanager.secretAccessor).
Attendi il completamento del deployment.
Una volta eseguito il deployment, prendi nota dell'URL della funzione dall'output.

Configura Cloud Scheduler

Nella Google Cloud console, vai a Cloud Scheduler > Crea job.
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 * * * * (l'esecuzione avviene ogni 5 minuti, in corrispondenza del valore POLL_INTERVAL).
- Fuso orario: seleziona UTC.
- Tipo di destinazione: 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.
Fai clic su Crea.

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

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

Configura il bucket AWS S3 e IAM per Google SecOps

Crea un bucket Amazon S3 seguendo questa guida utente: Creazione di un bucket
Salva il nome e la regione del bucket per riferimento futuro (ad esempio, slack-audit-logs).
Crea un utente seguendo questa guida utente: Creazione di un utente IAM.
Seleziona l'utente creato.
Seleziona la scheda Credenziali di sicurezza.
Fai clic su Crea chiave di accesso nella sezione Chiavi di accesso.
Seleziona Servizio di terze parti come Caso d'uso.
Fai clic su Avanti.
(Facoltativo) Aggiungi il tag della descrizione.
Fai clic su Crea chiave di accesso.
Fai clic su Scarica file .csv per salvare la chiave di accesso e la chiave di accesso segreta per riferimento futuro.
Fai clic su Fine.
Seleziona la scheda Autorizzazioni.
Fai clic su Aggiungi autorizzazioni nella sezione Norme relative alle autorizzazioni.
Seleziona Aggiungi autorizzazioni.
Seleziona Allega direttamente i criteri.
Cerca i criteri AmazonS3FullAccess.
Seleziona la policy.
Fai clic su Avanti.
Fai clic su Aggiungi autorizzazioni.

Configura il ruolo e il criterio IAM per i caricamenti S3

Nella console AWS, vai a IAM > Policy > Crea policy > scheda JSON.
Copia e incolla il criterio riportato di seguito.

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"
    }
  ]
}

Fai clic su Avanti.
Inserisci il nome del criterio SlackAuditS3Policy.
Fai clic su Crea policy.
Vai a IAM > Ruoli > Crea ruolo > Servizio AWS > Lambda.
Allega la policy appena creata SlackAuditS3Policy.
Assegna al ruolo il nome SlackAuditToS3Role e fai clic su Crea ruolo.

Crea la funzione Lambda

Nella console AWS, vai a Lambda > Funzioni > Crea funzione.
Fai clic su Crea da zero.
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
Fai clic su Crea funzione.

Impostazione	Valore
Nome	`slack_audit_to_s3`
Tempo di esecuzione	Python 3.13
Architettura	x86_64
Ruolo di esecuzione	`SlackAuditToS3Role`

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())

Vai a Configurazione > Variabili di ambiente > Modifica > Aggiungi variabile di ambiente.

Inserisci le variabili di ambiente fornite di seguito, sostituendole con i tuoi valori.

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`

Fai clic su Salva.
Seleziona la scheda Configurazione.
Nel riquadro Configurazione generale, fai clic su Modifica.
Modifica Timeout impostando 5 minuti (300 secondi) e fai clic su Salva.

Nota: il timeout è un limite superiore rigido, il che significa che se la funzione è ancora in esecuzione quando il timer raggiunge i 5 minuti, AWS Lambda la terminerà. Qualsiasi esecuzione più breve termina normalmente e ti viene addebitato solo il tempo di esecuzione effettivo.

Creare una pianificazione EventBridge

Vai a Amazon EventBridge > Scheduler > Crea pianificazione.
Fornisci i seguenti dettagli di configurazione:
- Nome: inserisci slack-audit-1h.
- Programmazione ricorrente: seleziona Programmazione basata sulla tariffa.
- Espressione della tariffa: inserisci 1 ore.
- Finestra temporale flessibile: seleziona Off.
Fai clic su Avanti.
Seleziona Target:
- API di destinazione: seleziona AWS Lambda Invoke.
- Funzione Lambda: seleziona slack_audit_to_s3.
Fai clic su Avanti.
Fai clic su Avanti (salta le impostazioni facoltative).
Rivedi e fai clic su Crea pianificazione.

(Facoltativo) Crea chiavi e utenti IAM di sola lettura per Google SecOps

Vai a AWS Console > IAM > Users > Create user.
Fornisci i seguenti dettagli di configurazione:
- Nome utente: inserisci secops-reader.
- Tipo di accesso: seleziona Accesso programmatico.
Fai clic su Avanti.
Seleziona Allega direttamente i criteri.
Fai clic su Crea policy.

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"
    }
  ]
}

Fai clic su Avanti.
Inserisci il nome del criterio secops-reader-policy.
Fai clic su Crea policy.
Torna alla pagina di creazione dell'utente, aggiorna l'elenco delle policy e seleziona secops-reader-policy.
Fai clic su Avanti.
Fai clic su Crea utente.
Seleziona l'utente creato secops-reader.
Vai a Credenziali di sicurezza > Chiavi di accesso > Crea chiave di accesso.
Seleziona Servizio di terze parti.
Fai clic su Avanti.
Fai clic su Crea chiave di accesso.
Fai clic su Scarica file .csv per salvare le credenziali.

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

Vai a Impostazioni SIEM > Feed.
Fai clic su Aggiungi nuovo.
Nel campo Nome feed, inserisci un nome per il feed (ad esempio, Slack Audit Logs).
Seleziona Amazon S3 V2 come Tipo di origine.
Seleziona Audit di Slack come Tipo di log.
Fai clic su Avanti.
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 nell'ultimo numero di 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 segreta: chiave segreta dell'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.
Fai clic su Avanti.
Controlla la nuova configurazione del feed nella schermata Finalizza e poi fai clic su Invia.

Tabella di mappatura UDM

Campo log	Mappatura UDM	Logic
`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 Unix del 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 in base al 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". Imposta "Enterprise Grid" se esiste `date_create`, altrimenti imposta "Log di controllo" se esiste `user_id`. Codificato in modo permanente su "Slack". Codificato come "REMOTE". Imposta "SSO" se `action` contiene "user_login" o "user_logout". In caso contrario, imposta "MACHINE". Non mappato negli esempi forniti. Il valore predefinito è "ALLOW", ma è impostato su "BLOCK" se `action` è "user_login_failed". Imposta "Slack" se esiste `date_create`, altrimenti imposta "SLACK" se esiste `user_id`.
`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.