Raccogliere i log di Salesforce Commerce Cloud

Supportato in:

Questo documento spiega come importare i log di Salesforce Commerce Cloud in Google Security Operations utilizzando Google Cloud Storage V2.

Salesforce Commerce Cloud è una piattaforma di e-commerce che genera log di controllo di transazioni, accesso e sicurezza. Una funzione Cloud Run si connette all'endpoint WebDAV di Salesforce Commerce Cloud in base a una pianificazione, scarica i file di log, li scrive in un bucket GCS in formato NDJSON e Google SecOps li acquisisce tramite un feed GCS V2.

Prima di iniziare

Assicurati di soddisfare i seguenti prerequisiti:

  • Un'istanza Google SecOps
  • Un progetto GCP con l'API Storage Cloud abilitata
  • Autorizzazioni per creare e gestire bucket GCS
  • Autorizzazioni per gestire le policy IAM nei bucket GCS
  • Autorizzazioni per creare servizi Cloud Run, argomenti Pub/Sub e job Cloud Scheduler
  • Accesso privilegiato a Salesforce Commerce Cloud Business Manager con autorizzazione di accesso WebDAV

Crea un bucket Google Cloud Storage

  1. Vai alla console Google Cloud.
  2. Seleziona il tuo progetto o creane uno nuovo.
  3. Nel menu di navigazione, vai a Cloud Storage > Bucket.
  4. Fai clic su Crea bucket.

  5. Fornisci i seguenti dettagli di configurazione:

    Impostazione Valore
    Assegna un nome al bucket Inserisci un nome univoco globale (ad esempio sfcc-logs).
    Tipo di località Scegli in base alle tue esigenze (regione singola, a due regioni, multiregionale)
    Località Seleziona la posizione (ad esempio, us-central1).
    Classe di archiviazione Standard (consigliato per i log a cui si accede di frequente)
    Controllo dell'accesso Uniforme (consigliato)
    Strumenti di protezione (Facoltativo) Attiva il controllo delle versioni degli oggetti o la policy di conservazione

  6. Fai clic su Crea.

Raccogliere le credenziali di Salesforce Commerce Cloud

Configurare l'accesso WebDAV

  1. Accedi a Business Manager per la tua istanza di Salesforce Commerce Cloud.
  2. Vai ad Amministrazione > Organizzazione > Ruoli e autorizzazioni.
  3. Verifica che l'autorizzazione Accesso ai file WebDAV sia abilitata per il tuo account utente.
  4. Prendi nota del nome host dell'istanza SFCC (ad esempio, development-yoursite-dw.demandware.net).

  5. Salva le seguenti credenziali in una posizione sicura:

    • Host SFCC: il nome host dell'istanza (ad esempio, development-yoursite-dw.demandware.net).
    • Nome utente: il tuo nome utente Business Manager.
    • Password: la password di Business Manager.

Verifica le autorizzazioni

Per verificare che l'account disponga delle autorizzazioni richieste:

  1. Accedi a Business Manager per la tua istanza di Salesforce Commerce Cloud.
  2. Vai ad Amministrazione > Sviluppo del sito > Configurazione sviluppo.
  3. Fai clic su File di log nella sezione WebDAV.
  4. Se riesci a visualizzare le directory dei file di log, disponi delle autorizzazioni richieste.
  5. Se non riesci a visualizzare questa opzione, contatta l'amministratore di SFCC per concedere l'accesso WebDAV.

Testare l'accesso API

  • Verifica le tue credenziali prima di procedere con l'integrazione:

    # Replace with your actual credentials
SFCC_HOST="development-yoursite-dw.demandware.net"
USERNAME="your-username"
PASSWORD="your-password"

# Test WebDAV access to log directory
curl -v -u "${USERNAME}:${PASSWORD}" \
  "https://${SFCC_HOST}/on/demandware.servlet/webdav/Sites/Logs/"

Crea un account di servizio per la funzione Cloud Run

La funzione Cloud Run richiede un account di servizio con autorizzazioni per scrivere nel bucket GCS e per essere richiamato da Pub/Sub.

Crea service account

  1. Nella console Google Cloud, vai a IAM e amministrazione > Service account.
  2. Fai clic su Crea account di servizio.
  3. Fornisci i seguenti dettagli di configurazione:
    • Nome del service account: inserisci sfcc-logs-collector-sa.
    • Descrizione service account: inserisci Service account for Cloud Run function to collect Salesforce Commerce Cloud logs.
  4. Fai clic su Crea e continua.
  5. Nella sezione Concedi a questo account di servizio l'accesso al progetto, aggiungi i seguenti ruoli:
    1. Fai clic su Seleziona un ruolo.
    2. Cerca e seleziona Storage Object Admin.
    3. Fai clic su + Aggiungi un altro ruolo.
    4. Cerca e seleziona Cloud Run Invoker.
    5. Fai clic su + Aggiungi un altro ruolo.
    6. Cerca e seleziona Invoker di Cloud Functions.
  6. Fai clic su Continua.
  7. Fai clic su Fine.

Questi ruoli sono necessari per:

  • Storage Object Admin: scrive i log nel bucket GCS e gestisce i file di stato
  • Cloud Run Invoker: consente a Pub/Sub di richiamare la funzione
  • Cloud Functions Invoker: consente la chiamata di funzioni

Concedi autorizzazioni IAM sul bucket GCS

Concedi al account di servizio le autorizzazioni di scrittura sul bucket GCS:

  1. Vai a Cloud Storage > Bucket.
  2. Fai clic sul nome del bucket (ad esempio sfcc-logs).
  3. Vai alla scheda Autorizzazioni.
  4. Fai clic su Concedi l'accesso.
  5. Fornisci i seguenti dettagli di configurazione:
    • Aggiungi entità: inserisci l'email del account di servizio (ad esempio, sfcc-logs-collector-sa@your-project.iam.gserviceaccount.com).
    • Assegna i ruoli: seleziona Storage Object Admin.
  6. Fai clic su Salva.

Crea argomento Pub/Sub

Crea un argomento Pub/Sub a cui Cloud Scheduler pubblicherà e a cui la funzione Cloud Run si iscriverà.

  1. Nella console GCP, vai a Pub/Sub > Argomenti.
  2. Fai clic su Crea argomento.
  3. Fornisci i seguenti dettagli di configurazione:
    • ID argomento: inserisci sfcc-logs-trigger.
    • Lascia invariate le altre impostazioni predefinite.
  4. Fai clic su Crea.

Crea una funzione Cloud Run per raccogliere i log

La funzione Cloud Run verrà attivata dai messaggi Pub/Sub di Cloud Scheduler per recuperare i log da Salesforce Commerce Cloud WebDAV e scriverli in GCS.

  1. Nella console GCP, vai a Cloud Run.
  2. Fai clic su Crea servizio.
  3. Seleziona Funzione (usa un editor in linea per creare una funzione).

  4. Nella sezione Configura, fornisci i seguenti dettagli di configurazione:

    Impostazione Valore
    Nome servizio sfcc-logs-collector
    Regione Seleziona la regione corrispondente al tuo bucket GCS (ad esempio, us-central1)
    Tempo di esecuzione Seleziona Python 3.12 o versioni successive

  5. Nella sezione Trigger (facoltativo):

    1. Fai clic su + Aggiungi trigger.
    2. Seleziona Cloud Pub/Sub.
    3. In Seleziona un argomento Cloud Pub/Sub, scegli l'argomento sfcc-logs-trigger.
    4. Fai clic su Salva.

  6. Nella sezione Autenticazione:

    1. Seleziona Richiedi autenticazione.
    2. Controlla Identity and Access Management (IAM).

  7. Scorri verso il basso ed espandi Container, networking, sicurezza.

  8. Vai alla scheda Sicurezza:

    • Service account: seleziona il account di servizio sfcc-logs-collector-sa.

  9. Vai alla scheda Container:

    1. Fai clic su Variabili e secret.
    2. Fai clic su + Aggiungi variabile per ogni variabile di ambiente:
    Nome variabile Valore di esempio Descrizione
    GCS_BUCKET sfcc-logs Nome del bucket GCS
    GCS_PREFIX sfcc Prefisso per i file di log
    STATE_KEY sfcc/state.json Percorso file di stato
    SFCC_HOST development-yoursite-dw.demandware.net Nome host dell'istanza SFCC
    SFCC_USERNAME your-username Nome utente Business Manager
    SFCC_PASSWORD your-password Password di Business Manager
    LOG_DIRS security,error,warn,customerror Directory dei log separate da virgole
    LOOKBACK_HOURS 24 Periodo di riferimento iniziale

  10. Scorri verso il basso nella scheda Variabili e secret fino a Richieste:

    • Timeout richiesta: inserisci 600 secondi (10 minuti).

  11. Vai alla scheda Impostazioni in Container:

    • Nella sezione Risorse:
      • Memoria: seleziona 512 MiB o un valore superiore.
      • CPU: seleziona 1.
    • Fai clic su Fine.

  12. Scorri verso il basso fino a Ambiente di esecuzione:

    • Seleziona Predefinito (opzione consigliata).

  13. Nella sezione Scalabilità della revisione:

    • Numero minimo di istanze: inserisci 0.
    • Numero massimo di istanze: inserisci 100 (o modifica in base al carico previsto).

  14. Fai clic su Crea.

  15. Attendi la creazione del servizio (1-2 minuti).

  16. Dopo aver creato il servizio, si aprirà automaticamente l'editor di codice incorporato.

Aggiungi codice per la funzione

  1. Inserisci main in Entry point della funzione.

  2. Nell'editor di codice incorporato, crea due file:

    • Primo file:main.py:

      import functions_framework
from google.cloud import storage
import json
import os
import urllib3
from datetime import datetime, timezone, timedelta
import time
import base64
import re

# Initialize HTTP client with timeouts
http = urllib3.PoolManager(
  timeout=urllib3.Timeout(connect=10.0, read=60.0),
  retries=False,
)

# Initialize Storage client
storage_client = storage.Client()

# Environment variables
GCS_BUCKET = os.environ.get('GCS_BUCKET')
GCS_PREFIX = os.environ.get('GCS_PREFIX', 'sfcc')
STATE_KEY = os.environ.get('STATE_KEY', 'sfcc/state.json')
SFCC_HOST = os.environ.get('SFCC_HOST')
SFCC_USERNAME = os.environ.get('SFCC_USERNAME')
SFCC_PASSWORD = os.environ.get('SFCC_PASSWORD')
LOG_DIRS = [d.strip() for d in os.environ.get('LOG_DIRS', 'security,error,warn,customerror').split(',') if d.strip()]
LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24'))

def parse_datetime(value: str) -> datetime:
  """Parse ISO datetime string to datetime object."""
  if value.endswith("Z"):
    value = value[:-1] + "+00:00"
  return datetime.fromisoformat(value)

@functions_framework.cloud_event
def main(cloud_event):
  """
  Cloud Run function triggered by Pub/Sub to fetch Salesforce Commerce Cloud
  logs via WebDAV and write to GCS.

  Args:
    cloud_event: CloudEvent object containing Pub/Sub message
  """

  if not all([GCS_BUCKET, SFCC_HOST, SFCC_USERNAME, SFCC_PASSWORD]):
    print('Error: Missing required environment variables')
    return

  try:
    bucket = storage_client.bucket(GCS_BUCKET)

    # Load state
    state = load_state(bucket, STATE_KEY)

    now = datetime.now(timezone.utc)
    last_time = None

    if isinstance(state, dict) and state.get("last_event_time"):
      try:
        last_time = parse_datetime(state["last_event_time"])
      except Exception as e:
        print(f"Warning: Could not parse last_event_time: {e}")

    if last_time is None:
      last_time = now - timedelta(hours=LOOKBACK_HOURS)

    print(f"Fetching logs since {last_time.isoformat()}")

    # Build auth header
    credentials = f"{SFCC_USERNAME}:{SFCC_PASSWORD}"
    encoded_credentials = base64.b64encode(credentials.encode('utf-8')).decode('utf-8')
    headers = {
      'Authorization': f'Basic {encoded_credentials}',
      'User-Agent': 'GoogleSecOps-SFCCCollector/1.0'
    }

    total_files = 0
    webdav_base = f"https://{SFCC_HOST}/on/demandware.servlet/webdav/Sites/Logs"

    for log_dir in LOG_DIRS:
      print(f"Processing log directory: {log_dir}")
      files_processed = fetch_and_upload_logs(
        bucket=bucket,
        webdav_base=webdav_base,
        log_dir=log_dir,
        headers=headers,
        since=last_time,
        now=now,
      )
      total_files += files_processed

    if total_files == 0:
      print("No new log files found.")
    else:
      print(f"Successfully processed {total_files} log files")

    save_state(bucket, STATE_KEY, now.isoformat())

  except Exception as e:
    print(f'Error processing logs: {str(e)}')
    raise

def load_state(bucket, key):
  """Load state from GCS."""
  try:
    blob = bucket.blob(key)
    if blob.exists():
      state_data = blob.download_as_text()
      return json.loads(state_data)
  except Exception as e:
    print(f"Warning: Could not load state: {e}")

  return {}

def save_state(bucket, key, last_event_time_iso: str):
  """Save the last event timestamp to GCS state file."""
  try:
    state = {'last_event_time': last_event_time_iso}
    blob = bucket.blob(key)
    blob.upload_from_string(
      json.dumps(state, indent=2),
      content_type='application/json'
    )
    print(f"Saved state: last_event_time={last_event_time_iso}")
  except Exception as e:
    print(f"Warning: Could not save state: {e}")

def list_webdav_files(webdav_url: str, headers: dict):
  """List files in a WebDAV directory using PROPFIND."""
  backoff = 1.0
  max_retries = 3

  for attempt in range(max_retries):
    response = http.request('PROPFIND', webdav_url, headers={**headers, 'Depth': '1'})

    if response.status == 429:
      retry_after = int(response.headers.get('Retry-After', str(int(backoff))))
      print(f"Rate limited (429). Retrying after {retry_after}s...")
      time.sleep(retry_after)
      backoff = min(backoff * 2, 30.0)
      continue

    if response.status not in (200, 207):
      print(f"HTTP Error listing {webdav_url}: {response.status}")
      return []

    content = response.data.decode('utf-8')
    # Parse file names from WebDAV PROPFIND XML response
    files = re.findall(r'<D:href>([^<]+)</D:href>', content)
    return [f for f in files if not f.endswith('/')]

  return []

def fetch_and_upload_logs(bucket, webdav_base: str, log_dir: str, headers: dict, since: datetime, now: datetime):
  """
  Fetch log files from a WebDAV directory and upload to GCS.

  Args:
    bucket: GCS bucket object
    webdav_base: WebDAV base URL
    log_dir: Log directory name
    headers: HTTP headers with auth
    since: Only process files newer than this
    now: Current time for file naming

  Returns:
    Number of files processed
  """
  dir_url = f"{webdav_base}/{log_dir}/"
  files = list_webdav_files(dir_url, headers)
  files_processed = 0
  backoff = 1.0

  for file_path in files:
    file_name = file_path.split('/')[-1]
    if not file_name:
      continue

    # Download file
    file_url = f"https://{SFCC_HOST}{file_path}"

    response = http.request('GET', file_url, headers=headers)

    if response.status == 429:
      retry_after = int(response.headers.get('Retry-After', str(int(backoff))))
      print(f"Rate limited (429). Retrying after {retry_after}s...")
      time.sleep(retry_after)
      backoff = min(backoff * 2, 30.0)
      response = http.request('GET', file_url, headers=headers)

    if response.status != 200:
      print(f"Error downloading {file_name}: {response.status}")
      continue

    backoff = 1.0
    content = response.data

    if not content:
      continue

    # Upload to GCS
    timestamp = now.strftime('%Y%m%d_%H%M%S')
    object_key = f"{GCS_PREFIX}/{log_dir}/{file_name}_{timestamp}"
    blob = bucket.blob(object_key)

    # Convert log lines to NDJSON
    lines = content.decode('utf-8', errors='replace').splitlines()
    records = []
    for line in lines:
      line = line.strip()
      if line:
        try:
          record = json.loads(line)
        except json.JSONDecodeError:
          record = {'raw_log': line, 'log_dir': log_dir, 'source_file': file_name}
        records.append(record)

    if records:
      ndjson = '\n'.join([json.dumps(r, ensure_ascii=False) for r in records]) + '\n'
      blob.upload_from_string(ndjson, content_type='application/x-ndjson')
      print(f"Uploaded {len(records)} records from {file_name} to gs://{GCS_BUCKET}/{object_key}")
      files_processed += 1

  return files_processed

    • Secondo file:requirements.txt:

      functions-framework==3.*
google-cloud-storage==2.*
urllib3>=2.0.0

  3. Fai clic su Esegui il deployment per salvare la funzione ed eseguirne il deployment.

  4. Attendi il completamento del deployment (2-3 minuti).

Crea job Cloud Scheduler

Cloud Scheduler pubblicherà messaggi nell'argomento Pub/Sub a intervalli regolari, attivando la funzione Cloud Run.

  1. Nella console GCP, vai a Cloud Scheduler.
  2. Fai clic su Crea job.

  3. Fornisci i seguenti dettagli di configurazione:

    Impostazione Valore
    Nome sfcc-logs-collector-hourly
    Regione Seleziona la stessa regione della funzione Cloud Run
    Frequenza 0 * * * * (ogni ora, all'ora)
    Fuso orario Seleziona il fuso orario (UTC consigliato)
    Tipo di target Pub/Sub
    Argomento Seleziona l'argomento sfcc-logs-trigger
    Corpo del messaggio {} (oggetto JSON vuoto)

  4. Fai clic su Crea.

Opzioni di frequenza di pianificazione

Scegli la frequenza in base al volume dei log e ai requisiti di latenza:

Frequenza Espressione cron Caso d'uso
Ogni 5 minuti */5 * * * * Volume elevato, bassa latenza
Ogni 15 minuti */15 * * * * Volume medio
Ogni ora 0 * * * * Standard (consigliato)
Ogni 6 ore 0 */6 * * * Volume basso, elaborazione batch
Ogni giorno 0 0 * * * Raccolta dei dati storici

Testare l'integrazione

  1. Nella console Cloud Scheduler, trova il tuo job (sfcc-logs-collector-hourly).
  2. Fai clic su Forza esecuzione per attivare manualmente.
  3. Attendi qualche secondo e vai a Cloud Run > Servizi > sfcc-logs-collector > Log.

  4. Verifica che la funzione sia stata eseguita correttamente. Cerca:

    Fetching logs since YYYY-MM-DDTHH:MM:SS+00:00
Processing log directory: security
Uploaded X records from filename.log to gs://sfcc-logs/sfcc/security/filename.log_YYYYMMDD_HHMMSS
Successfully processed X log files

  5. Controlla il bucket GCS (sfcc-logs) per verificare che i log siano stati scritti.

Se visualizzi errori nei log:

  • HTTP 401: controlla le credenziali SFCC nelle variabili di ambiente
  • HTTP 403: verifica che l'account disponga dell'autorizzazione di accesso ai file WebDAV in Business Manager
  • HTTP 429: limitazione di frequenza: la funzione eseguirà automaticamente un nuovo tentativo con backoff
  • Variabili di ambiente mancanti: controlla che tutte le variabili richieste siano impostate

Configura un feed in Google SecOps per importare i log di Salesforce Commerce Cloud

  1. Vai a Impostazioni SIEM > Feed.
  2. Fai clic su Aggiungi nuovo feed.
  3. Fai clic su Configura un singolo feed.
  4. Nel campo Nome feed, inserisci un nome per il feed (ad esempio, Salesforce Commerce Cloud Logs).
  5. Seleziona Google Cloud Storage V2 come Tipo di origine.
  6. Seleziona Salesforce Commerce Cloud come Tipo di log.

  7. Fai clic su Ottieni service account. Verrà visualizzata un'email del account di servizio univoca, ad esempio:

    chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com

  8. Copia l'indirizzo email. Lo utilizzerai nel prossimo passaggio.

  9. Fai clic su Avanti.

  10. Specifica i valori per i seguenti parametri di input:

    • URL del bucket di archiviazione: inserisci l'URI del bucket GCS con il percorso del prefisso:

      gs://sfcc-logs/sfcc/
      • Sostituisci:
        • sfcc-logs: il nome del bucket GCS.
        • sfcc/: il percorso del prefisso/della cartella in cui sono archiviati i log.

    • Opzione di eliminazione dell'origine: seleziona l'opzione di eliminazione in base alle tue preferenze:

      • Mai: non elimina mai i file dopo i trasferimenti (opzione consigliata per i test).
      • Elimina i file trasferiti: elimina i file dopo il trasferimento riuscito.

      • Elimina file trasferiti e directory vuote: elimina i file e le directory vuote dopo il trasferimento riuscito.

    • Età massima file: includi i file modificati nell'ultimo numero di giorni (il valore predefinito è 180 giorni).

    • Spazio dei nomi dell'asset: lo spazio dei nomi dell'asset.

    • Etichette di importazione: l'etichetta da applicare agli eventi di questo feed.

  11. Fai clic su Avanti.

  12. Controlla la nuova configurazione del feed nella schermata Finalizza e poi fai clic su Invia.

Concedi le autorizzazioni IAM al account di servizio Google SecOps

Il account di servizio Google SecOps deve avere il ruolo Visualizzatore oggetti Storage nel bucket GCS.

  1. Vai a Cloud Storage > Bucket.
  2. Fai clic sul nome del bucket (sfcc-logs).
  3. Vai alla scheda Autorizzazioni.
  4. Fai clic su Concedi l'accesso.
  5. Fornisci i seguenti dettagli di configurazione:
    • Aggiungi entità: incolla l'email del account di servizio Google SecOps.
    • Assegna ruoli: seleziona Visualizzatore oggetti Storage.

  6. Fai clic su Salva.

Tabella di mappatura UDM

Campo log Mappatura UDM Logica
auth.mechanism extensions.auth.mechanism Unita
csv_format extensions.auth.mechanism Mappato: false → auth.mechanism
event_id extensions.auth.mechanism Mappato: Login: Success → auth.mechanism
mechanism extensions.auth.mechanism Unita
LoginType extensions.auth.type Mappato: Application → AUTHTYPE_UNSPECIFIED
csv_format extensions.auth.type Mappato: false → AUTHTYPE_UNSPECIFIED
event_id extensions.auth.type Valori mappati (6 in totale, ad es. "Login", "LoginAsEvent", "IdentityVerificationEvent", "LoginE...
eventType.name metadata.description Mappato direttamente
metadata_description metadata.description Mappato direttamente
collected_timestamp metadata.event_timestamp Analizzato come yyyyMMddHHmmss
createdAt metadata.event_timestamp Analizzato come UNIX_MS
createdDate metadata.event_timestamp Analizzato come yyyy-MM-ddTHH:mm:ss.SSS
timestamp metadata.event_timestamp Analizzato come yyyyMMddHHmmss
ts_date metadata.event_timestamp Analizzato come yyyy-MM-dd HH:mm:ss.SSSZ
csv_format metadata.event_type Mappato: false → USER_LOGIN, false → USER_LOGOUT, false → `USER_RESOURCE_UPDATE_CON...
event_id metadata.event_type Mappato: Login: Success → USER_LOGIN, Logout → USER_LOGOUT
event_type metadata.event_type Mappato direttamente
label metadata.ingestion_labels Unita
resource_name metadata.ingestion_labels Mappato: `"ReportEvent","SessionHijackingEventStore","BulkApiResultEventStore","CredentialStu...
attrs.cat metadata.product_event_type Rinominate/mappate
eventType.id metadata.product_event_type Mappato direttamente
event_id metadata.product_event_type Mappato direttamente
event_identifier metadata.product_log_id Mappato direttamente
id metadata.product_log_id Mappato direttamente
protocol network.application_protocol Mappato direttamente
transaction_id network.dhcp.transaction_id Mappato direttamente
referral_url network.http.referral_url Mappato direttamente
request_status network.http.response_code Mappato direttamente
attrs.Application principal.application Rinominate/mappate
enterpriseId principal.group.product_object_id Mappato direttamente
attrs.src principal.ip Unita
csv_format principal.ip Mappato: false → attrs.src
event_id principal.ip Mappato: Login: Success → attrs.src
Status_LK principal.labels Unita
Status_LK principal.resource.attribute.labels Unita
browser_name principal.resource.name Mappato direttamente
memberId principal.resource.product_object_id Mappato direttamente
principal_resource_type principal.resource.type Mappato direttamente
attrs.usrName principal.user.email_addresses Unita
csv_format principal.user.email_addresses Mappato: false → attrs.usrName
src_email principal.user.email_addresses Unita
attrs.USER_ID_DERIVED principal.user.product_object_id Rinominate/mappate
employee.employeeName principal.user.user_display_name Mappato direttamente
user_display_name principal.user.user_display_name Mappato direttamente
attrs.usrName principal.user.userid Mappato direttamente
employee.userName principal.user.userid Mappato direttamente
login_key principal.user.userid Mappato direttamente
user_id principal.user.userid Mappato direttamente
csv_format security_result Mappato: false → sec_result
event_id security_result Mappato: Login: Success → sec_result
sec_result security_result Unita
sr security_result Unita
action security_result.action Unita
eventSource.name src.resource.name Mappato direttamente
eventSource.id src.resource.product_object_id Mappato direttamente
organization_id target.administrative_domain Mappato direttamente
target_hostname target.asset.hostname Mappato direttamente
device_id target.asset_id Mappato direttamente
target_hostname target.hostname Mappato direttamente
call_time target.resource.attribute.labels Unita
cpu target.resource.attribute.labels Unita
db_cpu target.resource.attribute.labels Unita
db_type target.resource.attribute.labels Unita
duration_time target.resource.attribute.labels Unita
entry_p target.resource.attribute.labels Unita
exe_time target.resource.attribute.labels Unita
no_sql_que target.resource.attribute.labels Unita
ope target.resource.attribute.labels Unita
rows_proc target.resource.attribute.labels Unita
run target.resource.attribute.labels Unita
ses_level target.resource.attribute.labels Unita
ss_type target.resource.attribute.labels Unita
total_time target.resource.attribute.labels Unita
user_ty target.resource.attribute.labels Unita
verify_method target.resource.attribute.labels Unita
attrs.AccountId target.resource.id Rinominate/mappate
attrs.CaseId target.resource.id Rinominate/mappate
attrs.ContactId target.resource.id Rinominate/mappate
eventSource.id target.resource.id Mappato direttamente
request_id target.resource.id Mappato direttamente
eventSource.name target.resource.name Mappato direttamente
object.name target.resource.name Mappato direttamente
resource_name target.resource.name Mappato direttamente
object.id target.resource.product_object_id Mappato direttamente
event_id target.resource.resource_type Mappato: PlatformEncryption → ACCESS_POLICY, ApexCallout → ACCESS_POLICY, `ApexTrigge...
target_resource_type target.resource.resource_type Mappato direttamente
event_id target.resource.type Mappato: (QueuedExecution/ApexExecution) → BATCH, ApexTrigger → DATABASE_TRIGGER, `Co...
attrs.LoginUrl target.url Rinominate/mappate
attrs.attributes.url target.url Rinominate/mappate
uri target.url Mappato direttamente
attrs.usrName target.user.email_addresses Unita
csv_format target.user.email_addresses Mappato: false → attrs.usrName
event_id target.user.email_addresses Mappato: Logout → attrs.usrName
target_user_display_name target.user.user_display_name Mappato direttamente
target_user_name target.user.userid Mappato direttamente
N/D extensions.auth.auth_details Costante: ACTIVE
N/D extensions.auth.type Costante: SSO
N/D metadata.event_type Costante: GENERIC_EVENT
N/D metadata.product_name Costante: SALESFORCE
N/D metadata.vendor_name Costante: SALESFORCE
N/D target.resource.resource_type Costante: ACCESS_POLICY
N/D target.resource.type Costante: BATCH

Log delle modifiche

Visualizza il log delle modifiche per questo parser

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