Collecter les journaux Asset Panda

Version de l'analyseur : 1.0

Compatible avec :

Ce document explique comment ingérer des journaux Asset Panda dans Google Security Operations à l'aide de Google Cloud Storage V2.

Asset Panda est une plate-forme de gestion des ressources basée sur le cloud qui permet aux organisations de suivre, de gérer et de créer des rapports sur les ressources physiques et numériques tout au long de leur cycle de vie. L'API REST Asset Panda permet d'accéder aux journaux des modifications qui enregistrent les modifications au niveau des champs, les transferts d'éléments, l'historique des actions et l'activité des utilisateurs dans tous les groupes d'éléments. Ces journaux de modifications peuvent être collectés via l'API et écrits dans un bucket GCS pour être ingérés par Google SecOps.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

  • Une instance Google SecOps
  • Un projet GCP avec l'API Cloud Storage activée
  • Autorisations de créer et de gérer des buckets GCS
  • Autorisations permettant de créer des services Cloud Run, des sujets Pub/Sub et des jobs Cloud Scheduler
  • Un compte Asset Panda avec un accès administrateur (requis pour la configuration de l'API)
  • Une clé API et un secret Asset Panda avec des autorisations de lecture

Générer des identifiants d'API Asset Panda

  1. Connectez-vous à votre compte Asset Panda en tant qu'administrateur.
  2. Cliquez sur l'icône Paramètres (roue dentée) en haut à droite.
  3. Sélectionnez Configuration de l'API.

Créer une clé API

  1. Sur la page Configuration de l'API, cliquez sur Créer une clé API.

  2. Fournissez les informations de configuration suivantes :

    • Nom : saisissez un nom descriptif pour la clé (par exemple, SIEM Change Log Collector).
    • Autorisations : sélectionnez Lecture.

  3. Cliquez sur Enregistrer.

  4. Enregistrez les identifiants suivants affichés en bas de la page :

    • Clé API (également appelée ID client)
    • Code secret de l'API (également appelé "code secret du client")

Identifier les ID de groupe

La fonction Cloud Run a besoin des ID de groupe pour interroger les objets et leurs journaux de modifications. Pour trouver les ID de vos groupes :

  1. Dans Asset Panda, accédez à Settings > Group Settings (Paramètres > Paramètres du groupe).
  2. Cliquez sur le lien Modifier à côté du nom d'un groupe.
  3. Notez la valeur numérique située vers la fin de l'URL du navigateur. Il s'agit de l'ID du groupe (par exemple, 12345).
  4. Répétez l'opération pour chaque groupe dont vous souhaitez collecter les journaux des modifications.

Tester l'accès à l'API

  • Testez vos identifiants avant de procéder à l'intégration :

    API_KEY="your-api-key"
API_SECRET="your-api-secret"

# Test authentication by retrieving account settings
curl -s "https://api.assetpanda.com/v3/settings" \
  -H "Accept: application/json" \
  -H "Access-Key-Id: ${API_KEY}" \
  -H "Access-Key-Secret: ${API_SECRET}"

Créer un bucket Google Cloud Storage

  1. Accédez à la console Google Cloud.
  2. Sélectionnez votre projet ou créez-en un.
  3. Dans le menu de navigation, accédez à Cloud Storage > Buckets.
  4. Cliquez sur Créer un bucket.

  5. Fournissez les informations de configuration suivantes :

    Paramètre Valeur
    Attribuez un nom au bucket Saisissez un nom unique (par exemple, asset-panda-change-logs).
    Type d'emplacement Choisissez celle qui correspond le mieux à vos besoins (régionale, birégionale ou multirégionale).
    Emplacement Sélectionnez l'emplacement (par exemple, us-central1).
    Classe de stockage Standard (recommandé pour les journaux fréquemment consultés)
    Access control (Contrôle des accès) Uniforme (recommandé)
    Outils de protection Facultatif : Activez la gestion des versions d'objets ou la règle de conservation.

  6. Cliquez sur Créer.

Créer un compte de service pour la fonction Cloud Run

La fonction Cloud Run a besoin d'un compte de service autorisé à écrire dans le bucket GCS et à être appelée par Pub/Sub.

Créer le compte de service

  1. Dans la console GCP, accédez à IAM et administration > Comptes de service.
  2. Cliquez sur Créer un compte de service.
  3. Fournissez les informations de configuration suivantes :
    • Nom du compte de service : saisissez asset-panda-logs-collector-sa.
    • Description du compte de service : saisissez Service account for Cloud Run function to collect Asset Panda change logs.
  4. Cliquez sur Créer et continuer.
  5. Dans la section Autoriser ce compte de service à accéder au projet, ajoutez les rôles suivants :
    1. Cliquez sur Sélectionner un rôle.
    2. Recherchez et sélectionnez Administrateur des objets Storage.
    3. Cliquez sur + Ajouter un autre rôle.
    4. Recherchez et sélectionnez Demandeur Cloud Run.
    5. Cliquez sur + Ajouter un autre rôle.
    6. Recherchez et sélectionnez Demandeur Cloud Functions.
  6. Cliquez sur Continuer.
  7. Cliquez sur OK.

Ces rôles sont requis pour :

  • Administrateur des objets de l'espace de stockage : écrire des journaux dans un bucket GCS et gérer les fichiers d'état
  • Demandeur Cloud Run : autorise Pub/Sub à appeler la fonction.
  • Demandeur Cloud Functions : autorise l'appel de fonctions.

Accorder des autorisations IAM sur le bucket GCS

Accordez au compte de service des autorisations d'écriture sur le bucket GCS :

  1. Accédez à Cloud Storage > Buckets.
  2. Cliquez sur le nom de votre bucket.
  3. Accédez à l'onglet Autorisations.
  4. Cliquez sur Accorder l'accès.
  5. Fournissez les informations de configuration suivantes :
    • Ajouter des comptes principaux : saisissez l'adresse e-mail du compte de service (par exemple, asset-panda-logs-collector-sa@PROJECT_ID.iam.gserviceaccount.com).
    • Attribuer des rôles : sélectionnez Administrateur des objets Storage.
  6. Cliquez sur Enregistrer.

Créer un sujet Pub/Sub

Créez un sujet Pub/Sub dans lequel Cloud Scheduler publiera des messages et auquel la fonction Cloud Run s'abonnera.

  1. Dans la console GCP, accédez à Pub/Sub > Sujets.
  2. Cliquez sur Créer un sujet.
  3. Fournissez les informations de configuration suivantes :
    • ID du sujet : saisissez asset-panda-logs-trigger.
    • Conservez les valeurs par défaut des autres paramètres.
  4. Cliquez sur Créer.

Créer une fonction Cloud Run pour collecter les journaux

La fonction Cloud Run sera déclenchée par les messages Pub/Sub de Cloud Scheduler pour récupérer les journaux des modifications à partir de l'API REST Asset Panda et les écrire dans GCS.

  1. Dans la console GCP, accédez à Cloud Run.
  2. Cliquez sur Créer un service.
  3. Sélectionnez Fonction (utilisez un éditeur de modification directe pour créer une fonction).

  4. Dans la section Configurer, fournissez les informations de configuration suivantes :

    Paramètre Valeur
    Nom du service asset-panda-logs-collector
    Région Sélectionnez la région correspondant à votre bucket GCS (par exemple, us-central1).
    Durée d'exécution Sélectionnez Python 3.12 ou une version ultérieure.

  5. Dans la section Déclencheur (facultatif) :

    1. Cliquez sur + Ajouter un déclencheur.
    2. Sélectionnez Cloud Pub/Sub.
    3. Dans Sélectionner un sujet Cloud Pub/Sub, choisissez le sujet asset-panda-logs-trigger.
    4. Cliquez sur Enregistrer.

  6. Dans la section Authentification :

    1. Sélectionnez Exiger l'authentification.
    2. Vérifiez Identity and Access Management (IAM).

  7. Faites défiler la page vers le bas, puis développez Conteneurs, mise en réseau, sécurité.

  8. Accédez à l'onglet Sécurité :

    • Compte de service : sélectionnez le compte de service asset-panda-logs-collector-sa.

  9. Accédez à l'onglet Conteneurs :

    1. Cliquez sur Variables et secrets.
    2. Cliquez sur + Ajouter une variable pour chaque variable d'environnement :
    Nom de la variable Exemple de valeur Description
    GCS_BUCKET asset-panda-change-logs Nom du bucket GCS
    GCS_PREFIX asset-panda Préfixe des fichiers journaux
    STATE_KEY asset-panda/state.json Chemin d'accès au fichier d'état
    AP_API_KEY your-api-key Clé API Asset Panda
    AP_API_SECRET your-api-secret Code secret de l'API Asset Panda
    AP_GROUP_IDS 12345,67890 ID de groupe à surveiller, séparés par une virgule
    PAGE_SIZE 50 Enregistrements par page d'API (50 max.)
    MAX_RECORDS 10000 Nombre maximal d'enregistrements par exécution
    LOOKBACK_HOURS 2 Période d'analyse initiale

  10. Faites défiler la section Variables et secrets vers le bas jusqu'à Requêtes :

    • Délai avant expiration de la requête : saisissez 600 secondes (10 minutes).

  11. Accédez à l'onglet Paramètres :

    • Dans la section Ressources :
      • Mémoire : sélectionnez 512 Mio ou plus.
      • Processeur : sélectionnez 1.

  12. Dans la section Scaling de révision :

    • Nombre minimal d'instances : saisissez 0.
    • Nombre maximal d'instances : saisissez 100 (ou ajustez en fonction de la charge attendue).

  13. Cliquez sur Créer.

  14. Attendez que le service soit créé (une à deux minutes).

  15. Une fois le service créé, l'éditeur de code intégré s'ouvre automatiquement.

Ajouter un code de fonction

  1. Saisissez main dans le champ Point d'entrée.

  2. Dans l'éditeur de code intégré, créez deux fichiers :

    • Premier fichier : main.py:

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

# Initialize HTTP client with timeouts
http = urllib3.PoolManager(
  timeout=urllib3.Timeout(connect=5.0, read=30.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', 'asset-panda').strip('/')
STATE_KEY = os.environ.get('STATE_KEY') or f"{GCS_PREFIX}/state.json"
AP_API_KEY = os.environ.get('AP_API_KEY')
AP_API_SECRET = os.environ.get('AP_API_SECRET')
AP_GROUP_IDS = os.environ.get('AP_GROUP_IDS', '')
PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '50'))
MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '10000'))
LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '2'))

BASE_URL = 'https://api.assetpanda.com'

# Rate limiting: 400 calls per 3 minutes
RATE_LIMIT_CALLS = 400
RATE_LIMIT_WINDOW = 180  # seconds
call_timestamps = []

def rate_limit_wait():
  """Enforce rate limiting of 400 calls per 3-minute window."""
  global call_timestamps
  now = time.time()
  call_timestamps = [t for t in call_timestamps if now - t < RATE_LIMIT_WINDOW]
  if len(call_timestamps) >= RATE_LIMIT_CALLS:
    sleep_time = RATE_LIMIT_WINDOW - (now - call_timestamps[0]) + 1
    print(f"Rate limit approaching. Sleeping {sleep_time:.1f}s...")
    time.sleep(sleep_time)
    call_timestamps = [t for t in call_timestamps if time.time() - t < RATE_LIMIT_WINDOW]
  call_timestamps.append(time.time())

def api_request(method, path, params=None):
  """Make an authenticated request to the Asset Panda API."""
  rate_limit_wait()

  url = f"{BASE_URL}{path}"
  headers = {
    'Accept': 'application/json',
    'Content-Type': 'application/json',
    'Access-Key-Id': AP_API_KEY,
    'Access-Key-Secret': AP_API_SECRET,
  }

  backoff = 1.0
  for attempt in range(3):
    try:
      if method == 'GET':
        response = http.request(method, url, headers=headers, fields=params)
      else:
        body = json.dumps(params or {}).encode('utf-8')
        response = http.request(method, url, headers=headers, body=body)

      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, 60.0)
        continue

      if response.status == 200:
        return json.loads(response.data.decode('utf-8'))

      print(f"HTTP {response.status}: {response.data.decode('utf-8')[:500]}")
      return None

    except Exception as e:
      print(f"Request error (attempt {attempt + 1}): {e}")
      if attempt < 2:
        time.sleep(backoff)
        backoff *= 2

  return None

def parse_datetime(value):
  """Parse ISO datetime string to datetime object."""
  if not value:
    return None
  if value.endswith("Z"):
    value = value[:-1] + "+00:00"
  try:
    return datetime.fromisoformat(value)
  except Exception:
    return None

@functions_framework.cloud_event
def main(cloud_event):
  """
  Cloud Run function triggered by Pub/Sub to fetch
  Asset Panda change logs and write to GCS.

  Args:
    cloud_event: CloudEvent object containing Pub/Sub message
  """
  if not all([GCS_BUCKET, AP_API_KEY, AP_API_SECRET, AP_GROUP_IDS]):
    print('Error: Missing required environment variables')
    return

  group_ids = [gid.strip() for gid in AP_GROUP_IDS.split(',') if gid.strip()]
  if not group_ids:
    print('Error: No group IDs configured')
    return

  try:
    bucket = storage_client.bucket(GCS_BUCKET)

    # Load state
    state = load_state(bucket, STATE_KEY)

    # Determine time window
    now = datetime.now(timezone.utc)
    last_time = None

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

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

    print(f"Collecting change logs from {last_time.isoformat()} to {now.isoformat()}")

    all_records = []

    for group_id in group_ids:
      if len(all_records) >= MAX_RECORDS:
        print(f"Reached max_records limit ({MAX_RECORDS})")
        break

      records = fetch_group_change_logs(group_id, last_time, now)
      all_records.extend(records)
      print(f"Group {group_id}: collected {len(records)} change log entries")

    if not all_records:
      print("No new change log records found.")
      save_state(bucket, STATE_KEY, now.isoformat())
      return

    # Write to GCS as NDJSON
    timestamp = now.strftime('%Y%m%d_%H%M%S')
    object_key = f"{GCS_PREFIX}/logs_{timestamp}.ndjson"
    blob = bucket.blob(object_key)

    ndjson = '\n'.join(
      [json.dumps(record, ensure_ascii=False) for record in all_records]
    ) + '\n'
    blob.upload_from_string(ndjson, content_type='application/x-ndjson')

    print(f"Wrote {len(all_records)} records to gs://{GCS_BUCKET}/{object_key}")

    # Update state
    save_state(bucket, STATE_KEY, now.isoformat())
    print(f"Successfully processed {len(all_records)} records")

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

def fetch_group_change_logs(group_id, start_time, end_time):
  """
  Fetch change logs for all objects in a group.

  Args:
    group_id: Asset Panda group ID
    start_time: Start time for log query
    end_time: End time for log query

  Returns:
    List of change log records
  """
  records = []
  offset = 0

  # Iterate through objects in the group
  while True:
    if len(records) >= MAX_RECORDS:
      break

    search_data = api_request(
      'POST',
      f'/v3/groups/{group_id}/search_objects',
      {'offset': offset, 'limit': PAGE_SIZE}
    )

    if not search_data:
      break

    objects = search_data.get('objects', [])
    if not objects:
      break

    for obj in objects:
      object_id = obj.get('id')
      if not object_id:
        continue

      change_logs = fetch_object_change_logs(
        object_id, group_id, start_time, end_time
      )
      records.extend(change_logs)

      if len(records) >= MAX_RECORDS:
        break

    total = search_data.get('totals', {}).get('objects', 0)
    offset += len(objects)
    if offset >= total:
      break

  return records

def fetch_object_change_logs(object_id, group_id, start_time, end_time):
  """
  Fetch change logs for a specific object.

  Args:
    object_id: Asset Panda object ID
    group_id: Asset Panda group ID
    start_time: Start time filter
    end_time: End time filter

  Returns:
    List of change log records with metadata
  """
  records = []
  offset = 0

  while True:
    data = api_request(
      'GET',
      f'/v3/entity_objects/{object_id}/change_logs',
      {'limit': PAGE_SIZE, 'offset': offset}
    )

    if not data:
      break

    logs = data.get('change_logs', data.get('data', []))
    if isinstance(logs, dict):
      logs = [logs]

    if not logs:
      break

    for log_entry in logs:
      log_time = parse_datetime(
        log_entry.get('created_at') or log_entry.get('updated_at', '')
      )

      if log_time and log_time < start_time:
        return records
      if log_time and log_time > end_time:
        continue

      log_entry['_group_id'] = group_id
      log_entry['_object_id'] = object_id
      records.append(log_entry)

    if len(logs) < PAGE_SIZE:
      break

    offset += len(logs)

  return records

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_run_time_iso):
  """Save the last run timestamp to GCS state file."""
  try:
    state = {'last_run_time': last_run_time_iso}
    blob = bucket.blob(key)
    blob.upload_from_string(
      json.dumps(state, indent=2),
      content_type='application/json'
    )
    print(f"Saved state: last_run_time={last_run_time_iso}")
  except Exception as e:
    print(f"Warning: Could not save state: {e}")

    • Deuxième fichier : requirements.txt:

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

  3. Cliquez sur Déployer pour enregistrer et déployer la fonction.

  4. Attendez la fin du déploiement (deux à trois minutes).

Créer une tâche Cloud Scheduler

Cloud Scheduler publiera des messages dans le sujet Pub/Sub à intervalles réguliers, ce qui déclenchera la fonction Cloud Run.

  1. Dans la console GCP, accédez à Cloud Scheduler.
  2. Cliquez sur Créer une tâche.

  3. Fournissez les informations de configuration suivantes :

    Paramètre Valeur
    Nom asset-panda-logs-collector-hourly
    Région Sélectionnez la même région que la fonction Cloud Run.
    Fréquence 0 * * * * (toutes les heures, à l'heure pile)
    Fuseau horaire Sélectionnez un fuseau horaire (UTC recommandé)
    Type de cible Pub/Sub
    Sujet Sélectionnez le sujet asset-panda-logs-trigger.
    Corps du message {} (objet JSON vide)

  4. Cliquez sur Créer.

Options de fréquence de programmation

Choisissez la fréquence en fonction du volume de journaux et des exigences de latence :

Fréquence Expression Cron Cas d'utilisation
Toutes les heures 0 * * * * Standard (recommandé)
Toutes les 2 heures 0 */2 * * * Baisser le volume
Toutes les 6 heures 0 */6 * * * Traitement par lot de faible volume

Tester l'intégration

  1. Dans la console Cloud Scheduler, recherchez votre job.
  2. Cliquez sur Forcer l'exécution pour déclencher le job manuellement.
  3. Patientez pendant quelques secondes.
  4. Accédez à Cloud Run > Services.
  5. Cliquez sur le nom de la fonction asset-panda-logs-collector.
  6. Cliquez sur l'onglet Journaux.

  7. Vérifiez que la fonction a bien été exécutée. Par exemple :

    Collecting change logs from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00
Group 12345: collected X change log entries
Wrote X records to gs://asset-panda-change-logs/asset-panda/logs_YYYYMMDD_HHMMSS.ndjson
Successfully processed X records

  8. Accédez à Cloud Storage > Buckets.

  9. Cliquez sur le nom de votre bucket.

  10. Accédez au dossier de préfixe asset-panda/.

  11. Vérifiez qu'un nouveau fichier .ndjson a été créé avec le code temporel actuel.

Si des erreurs s'affichent dans les journaux :

  • HTTP 401 : vérifiez les identifiants de l'API dans les variables d'environnement. Vérifiez que la clé API et le secret sont corrects.
  • HTTP 403 : vérifiez que les autorisations de lecture sont activées pour la clé API.
  • HTTP 429 : limitation du débit. La fonction effectuera automatiquement une nouvelle tentative avec intervalle exponentiel entre les tentatives.
  • Résultats vides : vérifiez que les ID de groupe configurés existent et contiennent des objets avec un historique des modifications.
  • Variables d'environnement manquantes : vérifiez que toutes les variables requises sont définies.

Configurer un flux dans Google SecOps pour ingérer les journaux Asset Panda

  1. Accédez à Paramètres > Gestion des données > Flux. Si vous utilisez une plate-forme SIEM uniquement, accédez à Paramètres > Flux.
  2. Cliquez sur Ajouter un flux d'actualités.
  3. Cliquez sur Configurer un flux unique.
  4. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Asset Panda Change Logs).
  5. Sélectionnez Google Cloud Storage V2 comme Type de source.
  6. Sélectionnez Asset Panda comme type de journal.

  7. Cliquez sur Get Service Account (Obtenir un compte de service). Une adresse e-mail de compte de service unique s'affiche, par exemple :

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

  8. Copiez cette adresse e-mail pour l'utiliser à l'étape suivante.

  9. Cliquez sur Suivant.

  10. Spécifiez les valeurs des paramètres d'entrée suivants :

    • URL du bucket de stockage : saisissez l'URI du bucket GCS avec le chemin d'accès du préfixe :

      gs://asset-panda-change-logs/asset-panda/
      • Remplacez :
        • asset-panda-change-logs : nom de votre bucket GCS.
        • asset-panda : préfixe/chemin d'accès au dossier facultatif où les journaux sont stockés (laissez ce champ vide pour la racine).

    • Option de suppression de la source : sélectionnez l'option de suppression de votre choix :

      • Jamais : ne supprime jamais les fichiers après les transferts (recommandé pour les tests).
      • Supprimer les fichiers transférés : supprime les fichiers après un transfert réussi.
      • Supprimer les fichiers transférés et les répertoires vides : supprime les fichiers et les répertoires vides une fois le transfert réussi.

    • Âge maximal du fichier : incluez les fichiers modifiés au cours d'un certain nombre de jours (180 jours par défaut).

    • Espace de noms de l'élément : espace de noms de l'élément

    • Étiquettes d'ingestion : étiquette à appliquer aux événements de ce flux.

  11. Cliquez sur Suivant.

  12. Vérifiez la configuration de votre nouveau flux d'actualités sur l'écran Finaliser, puis cliquez sur Envoyer.

Accorder des autorisations IAM au compte de service Google SecOps

Le compte de service Google SecOps doit disposer du rôle Lecteur des objets Storage sur votre bucket GCS.

  1. Accédez à Cloud Storage > Buckets.
  2. Cliquez sur le nom de votre bucket.
  3. Accédez à l'onglet Autorisations.
  4. Cliquez sur Accorder l'accès.
  5. Fournissez les informations de configuration suivantes :
    • Ajouter des comptes principaux : collez l'adresse e-mail du compte de service Google SecOps.
    • Attribuer des rôles : sélectionnez Lecteur d'objets Storage.

  6. Cliquez sur Enregistrer.

Table de mappage UDM

Champ du journal Mappage UDM Logique
array_values_label additional.fields Fusionné
data_label additional.fields Fusionné
field_values_label additional.fields Fusionné
low_values_label additional.fields Fusionné
value_ids_label additional.fields Fusionné
values_label additional.fields Fusionné
display_with_secondary intermediary.user.user_display_name Mappage direct
secondary_name intermediary.user.userid Mappage direct
created_at metadata.event_timestamp Analysé en tant que RFC 3339
has_user metadata.event_type Mappé : true → USER_UNCATEGORIZED
object_version_ids metadata.product_version Mappage direct
share_url metadata.url_back_to_product Mappage direct
display_name principal.user.user_display_name Mappage direct
id principal.user.userid Mappage direct
account_id_label security_result.detection_fields Fusionné
change_source_label security_result.detection_fields Fusionné
change_trigger_label security_result.detection_fields Fusionné
created_at_label security_result.detection_fields Fusionné
date_format_label security_result.detection_fields Fusionné
docusign_envelope_id_label security_result.detection_fields Fusionné
embedded_into_object_id_label security_result.detection_fields Fusionné
entity_action_id_label security_result.detection_fields Fusionné
entity_id_label security_result.detection_fields Fusionné
entity_id_label1 security_result.detection_fields Fusionné
entity_key_label security_result.detection_fields Fusionné
google_calendar_sync_label security_result.detection_fields Fusionné
gps_coordinates_label security_result.detection_fields Fusionné
has_audit_history_label security_result.detection_fields Fusionné
id_label security_result.detection_fields Fusionné
is_archived_label security_result.detection_fields Fusionné
is_deletable_label security_result.detection_fields Fusionné
is_editable_label security_result.detection_fields Fusionné
is_locked_label security_result.detection_fields Fusionné
linked_action_object_id_label security_result.detection_fields Fusionné
modifier_id_label security_result.detection_fields Fusionné
next_step_reservation_uid_label security_result.detection_fields Fusionné
object_appreciation_label security_result.detection_fields Fusionné
object_depreciation_label security_result.detection_fields Fusionné
oid_label security_result.detection_fields Fusionné
old_id_label security_result.detection_fields Fusionné
parent_action_object_id_label security_result.detection_fields Fusionné
predefined_forms_label security_result.detection_fields Fusionné
reservation_notification_label security_result.detection_fields Fusionné
reservation_uid_label security_result.detection_fields Fusionné
returned_label security_result.detection_fields Fusionné
state_label security_result.detection_fields Fusionné
status_label security_result.detection_fields Fusionné
updated_at_label security_result.detection_fields Fusionné
user_id_label security_result.detection_fields Fusionné
version_label security_result.detection_fields Fusionné
N/A metadata.event_type Constante : USER_UNCATEGORIZED

Journal des modifications

Afficher le journal des modifications de cet analyseur

Vous avez encore besoin d'aide ? Obtenez des réponses de membres de la communauté et de professionnels Google SecOps.