Raccogli i log di Salesforce Commerce Cloud

Supportata 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 audit log delle transazioni, degli accessi e della 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 importa 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 di Cloud Storage abilitata
  • Autorizzazioni per creare e gestire i bucket GCS
  • Autorizzazioni per gestire le policy IAM sui bucket GCS
  • Autorizzazioni per creare servizi Cloud Run, argomenti Pub/Sub e job Cloud Scheduler
  • Accesso con privilegi 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 globalmente univoco (ad esempio sfcc-logs)
    Tipo di località Scegli in base alle tue esigenze (Regione, a due regioni, multiregionale)
    Località Seleziona la località (ad esempio us-central1)
    Classe di archiviazione Standard (consigliato per i log ad accesso frequente)
    Controllo degli accessi Uniforme (consigliato)
    Strumenti di protezione (Facoltativo) Abilita il controllo delle versioni degli oggetti o la policy di conservazione
  6. Fai clic su Crea.

Raccogli le credenziali di Salesforce Commerce Cloud

Configura 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 per il tuo account utente sia abilitata l'autorizzazione Accesso ai file WebDAV.
  4. Prendi nota del nome host dell'istanza SFCC (ad esempio, development-yoursite-dw.demandware.net).
  5. Salva le seguenti credenziali in un luogo sicuro:

    • Host SFCC: il nome host dell'istanza (ad esempio, development-yoursite-dw.demandware.net).
    • Nome utente: il tuo nome utente di 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 Administration (Amministrazione) > Site Development (Sviluppo sito) > Development Setup (Configurazione sviluppo).
  3. Fai clic su File di log nella sezione WebDAV.
  4. Se riesci a visualizzare le directory dei file di log, significa che disponi delle autorizzazioni necessarie.
  5. Se non riesci a visualizzare questa opzione, contatta l'amministratore di SFCC per concedere l'accesso WebDAV.

Testa l'accesso all'API

  • Testa 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 le autorizzazioni per scrivere nel bucket GCS ed essere richiamata da Pub/Sub.

Crea service account

  1. Nella console Google Cloud, vai a IAM e amministrazione > Account di servizio.
  2. Fai clic su Crea account di servizio.
  3. Fornisci i seguenti dettagli di configurazione:
    • Nome 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 Cloud Functions Invoker.
  6. Fai clic su Continua.
  7. Fai clic su Fine.

Questi ruoli sono obbligatori 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 della funzione

Concedi le autorizzazioni IAM sul bucket GCS

Concedi al account di servizio le autorizzazioni in 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'indirizzo 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 in cui Cloud Scheduler pubblicherà e a cui la funzione Cloud Run si iscriverà.

  1. Nella console Google Cloud, 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 Google Cloud, vai a Cloud Run.
  2. Fai clic su Crea servizio.
  3. Seleziona Funzione (utilizza un editor di modifica 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 bucket GCS
    GCS_PREFIX sfcc Prefisso per i file di log
    STATE_KEY sfcc/state.json Percorso del file di stato
    SFCC_HOST development-yoursite-dw.demandware.net Nome host dell'istanza SFCC
    SFCC_USERNAME your-username Nome utente di 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 della 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 ad Ambiente di esecuzione:

    • Seleziona Predefinita (opzione consigliata).
  13. Nella sezione Scalabilità della revisione:

    • Numero minimo di istanze: inserisci 0.
    • Numero massimo di istanze: inserisci 100 (o regola 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, l'editor di codice incorporato si aprirà automaticamente.

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à i messaggi nell'argomento Pub/Sub a intervalli regolari, attivando la funzione Cloud Run.

  1. Nella console Google Cloud, 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, allo scoccare dell'ora)
    Fuso orario Seleziona il fuso orario (consigliato UTC)
    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 * * * Basso volume, elaborazione batch
Ogni giorno 0 0 * * * Raccolta dei dati storici

Testa l'integrazione

  1. Nella console Cloud Scheduler, individua 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 riproverà automaticamente con backoff
  • Variabili di ambiente mancanti: verifica 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 > Gestione dei dati > Feed. Se utilizzi una piattaforma solo SIEM, vai a Impostazioni > 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 es. 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à visualizzato un indirizzo email univoco del account di servizio, 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 bucket di archiviazione: inserisci l'URI del bucket GCS con il percorso del prefisso:

      gs://sfcc-logs/sfcc/
      
      • Sostituisci:
        • sfcc-logs: il nome del tuo bucket GCS.
        • sfcc/: 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 i file trasferiti e le directory vuote: elimina i file e le directory vuote dopo il trasferimento riuscito.

    • Età massima del file: includi i file modificati negli ultimi 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 di notizie 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 Storage Object Viewer 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'indirizzo 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 Mappatura: false → auth.mechanism
event_id extensions.auth.mechanism Mappatura: Login: Success → auth.mechanism
mechanism extensions.auth.mechanism Unita
LoginType extensions.auth.type Mappatura: Application → AUTHTYPE_UNSPECIFIED
csv_format extensions.auth.type Mappatura: false → AUTHTYPE_UNSPECIFIED
event_id extensions.auth.type Valori mappati (6 in totale, ad es. ` "Login", "LoginAsEvent", "IdentityVerificationEvent", "LoginE…
eventType.name metadata.description Mappatura diretta
metadata_description metadata.description Mappatura diretta
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 Mapped: false → USER_LOGIN, false → USER_LOGOUT, false → `USER_RESOURCE_UPDATE_CON…
event_id metadata.event_type Mappatura: Login: Success → USER_LOGIN, Logout → USER_LOGOUT
event_type metadata.event_type Mappatura diretta
label metadata.ingestion_labels Unita
resource_name metadata.ingestion_labels Mappati: `"ReportEvent","SessionHijackingEventStore","BulkApiResultEventStore","CredentialStu…
attrs.cat metadata.product_event_type Rinominato/mappato
eventType.id metadata.product_event_type Mappatura diretta
event_id metadata.product_event_type Mappatura diretta
event_identifier metadata.product_log_id Mappatura diretta
id metadata.product_log_id Mappatura diretta
protocol network.application_protocol Mappatura diretta
transaction_id network.dhcp.transaction_id Mappatura diretta
referral_url network.http.referral_url Mappatura diretta
request_status network.http.response_code Mappatura diretta
attrs.Application principal.application Rinominato/mappato
enterpriseId principal.group.product_object_id Mappatura diretta
attrs.src principal.ip Unita
csv_format principal.ip Mappatura: false → attrs.src
event_id principal.ip Mappatura: Login: Success → attrs.src
Status_LK principal.labels Unita
Status_LK principal.resource.attribute.labels Unita
browser_name principal.resource.name Mappatura diretta
memberId principal.resource.product_object_id Mappatura diretta
principal_resource_type principal.resource.type Mappatura diretta
attrs.usrName principal.user.email_addresses Unita
csv_format principal.user.email_addresses Mappatura: false → attrs.usrName
src_email principal.user.email_addresses Unita
attrs.USER_ID_DERIVED principal.user.product_object_id Rinominato/mappato
employee.employeeName principal.user.user_display_name Mappatura diretta
user_display_name principal.user.user_display_name Mappatura diretta
attrs.usrName principal.user.userid Mappatura diretta
employee.userName principal.user.userid Mappatura diretta
login_key principal.user.userid Mappatura diretta
user_id principal.user.userid Mappatura diretta
csv_format security_result Mappatura: false → sec_result
event_id security_result Mappatura: Login: Success → sec_result
sec_result security_result Unita
sr security_result Unita
action security_result.action Unita
eventSource.name src.resource.name Mappatura diretta
eventSource.id src.resource.product_object_id Mappatura diretta
organization_id target.administrative_domain Mappatura diretta
target_hostname target.asset.hostname Mappatura diretta
device_id target.asset_id Mappatura diretta
target_hostname target.hostname Mappatura diretta
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 Rinominato/mappato
attrs.CaseId target.resource.id Rinominato/mappato
attrs.ContactId target.resource.id Rinominato/mappato
eventSource.id target.resource.id Mappatura diretta
request_id target.resource.id Mappatura diretta
eventSource.name target.resource.name Mappatura diretta
object.name target.resource.name Mappatura diretta
resource_name target.resource.name Mappatura diretta
object.id target.resource.product_object_id Mappatura diretta
event_id target.resource.resource_type Mapped: PlatformEncryption → ACCESS_POLICY, ApexCallout → ACCESS_POLICY, `ApexTrigge…
target_resource_type target.resource.resource_type Mappatura diretta
event_id target.resource.type Mapped: (QueuedExecution/ApexExecution) → BATCH, ApexTrigger → DATABASE_TRIGGER, `Co…
attrs.LoginUrl target.url Rinominato/mappato
attrs.attributes.url target.url Rinominato/mappato
uri target.url Mappatura diretta
attrs.usrName target.user.email_addresses Unita
csv_format target.user.email_addresses Mappatura: false → attrs.usrName
event_id target.user.email_addresses Mappatura: Logout → attrs.usrName
target_user_display_name target.user.user_display_name Mappatura diretta
target_user_name target.user.userid Mappatura diretta
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.