Collecter les journaux Metabase

Compatible avec :

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

Metabase est une plate-forme d'informatique décisionnelle et d'analyse open source qui permet aux entreprises d'interroger des bases de données, de créer des visualisations et de concevoir des tableaux de bord. Dans les forfaits Pro et Enterprise, Metabase stocke les données d'utilisation et d'audit dans sa base de données d'application, y compris les journaux d'activité, les journaux de vues et les enregistrements d'exécution des requêtes. Une fonction Cloud Run interroge l'API Metabase pour récupérer ces données et les écrit dans un bucket GCS pour qu'elles soient ingérées par Google SecOps.

Avant de commencer

Assurez-vous de remplir les conditions préalables suivantes :

  • Une instance Google SecOps
  • Un projet GCP avec les API Cloud Storage, Cloud Run, Pub/Sub et Cloud Scheduler activées
  • Autorisations permettant de créer et de gérer des buckets GCS
  • Autorisations permettant de gérer les stratégies IAM sur les buckets GCS
  • Autorisations permettant de créer des services Cloud Run, des sujets Pub/Sub et des jobs Cloud Scheduler
  • Un forfait Metabase Pro ou Enterprise (les statistiques d'utilisation ne sont pas disponibles dans les éditions Open Source ni Cloud Starter)
  • Accès administrateur Metabase pour créer des clés API
  • La base de données de l'application Metabase ajoutée en tant que source de données dans Metabase (nécessaire pour interroger les tables d'audit via l'API)

Configurer l'accès à l'API Metabase

Pour permettre à Google SecOps de récupérer les données d'analyse de l'utilisation, vous devez créer une clé API dans Metabase et ajouter la base de données de l'application en tant que source de données interrogeable.

Créer une clé API

  1. Connectez-vous à votre instance Metabase en tant qu'administrateur.
  2. Cliquez sur l'icône en forme de roue dentée en haut à droite.
  3. Sélectionnez Paramètres d'administration.
  4. Accédez à l'onglet Paramètres.
  5. Cliquez sur l'onglet Authentification dans le menu de gauche.
  6. Faites défiler la page jusqu'à Clés API, puis cliquez sur Gérer.
  7. Cliquez sur le bouton Créer une clé API.
  8. Fournissez les informations de configuration suivantes :
    • Nom de la clé : saisissez un nom descriptif (par exemple, Google SecOps Integration).
    • Groupe : sélectionnez un groupe ayant accès aux autorisations de collecte et d'interrogation des données d'analyse de l'utilisation pour la base de données de l'application.
  9. Cliquez sur Créer.

  10. Copiez et enregistrez la clé API de manière sécurisée.

Ajouter la base de données de l'application comme source de données

Pour interroger les tables d'audit via l'API, vous devez ajouter la base de données de l'application Metabase en tant que source de données dans Metabase.

  1. Dans Metabase, cliquez sur l'icône en forme de roue dentée en haut à droite.
  2. Sélectionnez Paramètres d'administration.
  3. Accédez à l'onglet Bases de données.
  4. Cliquez sur Ajouter une base de données.
  5. Configurez la connexion à la base de données :
    • Type de base de données : sélectionnez PostgreSQL ou MySQL (selon la base de données de votre application).
    • Nom : saisissez Metabase Application Database.
    • Hôte : saisissez le nom d'hôte de la base de données de votre application.
    • Port : saisissez le port de la base de données (par défaut, 5432 pour PostgreSQL et 3306 pour MySQL).
    • Nom de la base de données : saisissez le nom de la base de données de l'application (par exemple, metabase).
    • Nom d'utilisateur : saisissez un utilisateur de base de données disposant des autorisations SELECT sur les tables audit_log, view_log et query_execution.
    • Mot de passe : saisissez le mot de passe de la base de données.
  6. Cliquez sur Enregistrer.
  7. Après l'enregistrement, notez l'ID de la base de données à partir de l'URL (par exemple, https://metabase.example.com/admin/databases/5 signifie que l'ID de la base de données est 5).

Vérifier les autorisations

Pour vérifier que la clé API dispose des autorisations requises :

  1. Connectez-vous à Metabase en tant qu'administrateur.
  2. Cliquez sur l'icône en forme de roue dentée > Paramètres d'administration > Personnes.
  3. Recherchez le groupe attribué à la clé API.
  4. Vérifiez que le groupe a accès à la collection Analytics sur l'utilisation.
  5. Accédez à Paramètres d'administration > Autorisations > Données.
  6. Vérifiez que le groupe dispose d'un accès Sans restriction ou Requête à la base de données de l'application.

Tester l'accès à l'API

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

    # Replace with your actual values
METABASE_URL="https://your-metabase-instance.com"
API_KEY="mb_your_api_key_here"
DATABASE_ID="5"

# Test API key authentication
curl -s -H "x-api-key: ${API_KEY}" \
  "${METABASE_URL}/api/database" \
  | python3 -m json.tool

# Test querying the application database for audit_log records
curl -s -X POST "${METABASE_URL}/api/dataset/json" \
  -H "x-api-key: ${API_KEY}" \
  -H "Content-Type: application/json" \
  -d "{\"database\": ${DATABASE_ID}, \"type\": \"native\", \"native\": {\"query\": \"SELECT * FROM audit_log ORDER BY id DESC LIMIT 5\", \"template-tags\": {}}, \"parameters\": []}" \
  | python3 -m json.tool

Une réponse réussie renvoie un tableau JSON des enregistrements du journal d'audit récents.

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, metabase-audit-logs).
    Type d'emplacement Choisissez en fonction de vos besoins (région, birégion, multirégion).
    Emplacement Sélectionnez l'emplacement (par exemple, us-central1).
    Classe de stockage Standard (recommandé pour les journaux auxquels vous accédez fréquemment)
    Access control (Contrôle des accès) Uniforme (recommandé)
    Outils de protection Facultatif : Activez la gestion des versions des 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 disposant des autorisations nécessaires pour écrire dans le bucket GCS et être appelée par Pub/Sub.

Créer un 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 metabase-audit-collector-sa.
    • Description du compte de service : saisissez Service account for Cloud Run function to collect Metabase audit 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 Storage : é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

  1. Accédez à Cloud Storage > Buckets.
  2. Cliquez sur le nom de votre bucket (metabase-audit-logs).
  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 (metabase-audit-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

  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 thème : saisissez metabase-audit-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 des messages Pub/Sub provenant de Cloud Scheduler pour extraire les données d'audit de l'API Metabase 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 intégré pour créer une fonction).

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

    Paramètre Valeur
    Nom du service metabase-audit-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 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, sélectionnez metabase-audit-trigger.
    4. Cliquez sur Enregistrer.

  6. Dans la section Authentification :

    1. Sélectionnez Exiger l'authentification.
    2. Consultez 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 metabase-audit-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 metabase-audit-logs Nom du bucket GCS
    GCS_PREFIX metabase-audit Préfixe des fichiers journaux
    STATE_KEY metabase-audit/state.json Chemin d'accès au fichier d'état
    METABASE_URL https://metabase.yourcompany.com URL de base de l'instance Metabase
    METABASE_API_KEY mb_your_api_key_here Clé API Metabase
    DATABASE_ID 5 ID de la base de données de l'application
    LOOKBACK_HOURS 24 Période d'analyse initiale
    PAGE_SIZE 2000 Enregistrements par requête API

  10. Dans la section Variables et secrets, faites défiler la page 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.
      • CPU : sélectionnez 1.

  12. Dans la section Scaling de révision :

    • Nombre minimal d'instances : saisissez 0.
    • Nombre maximal d'instances : saisissez 100.

  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 :

    • main.py:

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

http = urllib3.PoolManager(
  timeout=urllib3.Timeout(connect=10.0, read=60.0),
  retries=False,
)

storage_client = storage.Client()

GCS_BUCKET = os.environ.get('GCS_BUCKET')
GCS_PREFIX = os.environ.get('GCS_PREFIX', 'metabase-audit')
STATE_KEY = os.environ.get('STATE_KEY', 'metabase-audit/state.json')
METABASE_URL = os.environ.get('METABASE_URL', '').rstrip('/')
API_KEY = os.environ.get('METABASE_API_KEY')
DATABASE_ID = int(os.environ.get('DATABASE_ID', '1'))
LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24'))
PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '2000'))

TABLES = ['audit_log', 'view_log', 'query_execution']

TABLE_TIME_COLUMNS = {
  'audit_log': 'timestamp',
  'view_log': 'timestamp',
  'query_execution': 'started_at',
}

@functions_framework.cloud_event
def main(cloud_event):
  if not all([GCS_BUCKET, METABASE_URL, API_KEY]):
    print('Error: Missing required environment variables')
    return

  try:
    bucket = storage_client.bucket(GCS_BUCKET)
    state = load_state(bucket)
    now = datetime.now(timezone.utc)

    if isinstance(state, dict) and state.get('last_event_time'):
      try:
        last_val = state['last_event_time']
        if last_val.endswith('Z'):
          last_val = last_val[:-1] + '+00:00'
        last_time = datetime.fromisoformat(last_val)
        last_time = last_time - timedelta(minutes=2)
      except Exception as e:
        print(f"Warning: Could not parse last_event_time: {e}")
        last_time = now - timedelta(hours=LOOKBACK_HOURS)
    else:
      last_time = now - timedelta(hours=LOOKBACK_HOURS)

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

    all_records = []
    newest_time = None

    for table in TABLES:
      time_col = TABLE_TIME_COLUMNS[table]
      records = fetch_table(table, time_col, last_time, now)
      for r in records:
        r['_metabase_table'] = table
        t = r.get(time_col)
        if t and (newest_time is None or str(t) > str(newest_time)):
          newest_time = t
      all_records.extend(records)
      print(f"Table {table}: fetched {len(records)} records")

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

    timestamp = now.strftime('%Y%m%d_%H%M%S')
    object_key = f"{GCS_PREFIX}/metabase_audit_{timestamp}.ndjson"
    blob = bucket.blob(object_key)

    ndjson = '\n'.join(
      [json.dumps(r, ensure_ascii=False, default=str) for r 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}")

    save_state(bucket, str(newest_time) if newest_time else now.isoformat())

    print(f"Successfully processed {len(all_records)} records")

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

def fetch_table(table, time_col, start_time, end_time):
  start_str = start_time.strftime('%Y-%m-%d %H:%M:%S')
  end_str = end_time.strftime('%Y-%m-%d %H:%M:%S')

  all_records = []
  offset = 0
  max_pages = 50

  for page in range(max_pages):
    sql = (
      f"SELECT * FROM {table} "
      f"WHERE {time_col} >= '{start_str}' "
      f"AND {time_col} < '{end_str}' "
      f"ORDER BY {time_col} ASC "
      f"LIMIT {PAGE_SIZE} OFFSET {offset}"
    )

    query_body = {
      "database": DATABASE_ID,
      "type": "native",
      "native": {
        "query": sql,
        "template-tags": {}
      },
      "parameters": []
    }

    url = f"{METABASE_URL}/api/dataset/json"
    response = http.request(
      'POST', url,
      body=json.dumps(query_body).encode('utf-8'),
      headers={
        'x-api-key': API_KEY,
        'Content-Type': 'application/json'
      }
    )

    if response.status == 429:
      print(f"Rate limited on {table} query. Stopping pagination.")
      break

    if response.status != 200:
      print(f"{table} query failed: {response.status} - "
          f"{response.data.decode('utf-8')}")
      break

    page_results = json.loads(response.data.decode('utf-8'))

    if not page_results:
      break

    all_records.extend(page_results)
    print(f"{table} page {page + 1}: {len(page_results)} records "
        f"(total: {len(all_records)})")

    if len(page_results) < PAGE_SIZE:
      break

    offset += PAGE_SIZE

  return all_records

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

def save_state(bucket, last_event_time_iso):
  try:
    state = {
      'last_event_time': last_event_time_iso,
      'last_run': datetime.now(timezone.utc).isoformat()
    }
    blob = bucket.blob(STATE_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}")

    • 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

  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 metabase-audit-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électionner metabase-audit-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 5 minutes */5 * * * * Volume élevé, faible latence
Toutes les 15 minutes */15 * * * * Volume moyen
Toutes les heures 0 * * * * Standard (recommandé)
Toutes les 6 heures 0 */6 * * * Traitement par lot à faible volume
Tous les jours 0 0 * * * Collecte de données historiques

Tester l'intégration

  1. Dans la console Cloud Scheduler, recherchez votre job (metabase-audit-collector-hourly).
  2. Cliquez sur Exécuter de force pour déclencher le job manuellement.
  3. Patientez quelques secondes.
  4. Accédez à Cloud Run > Services.
  5. Cliquez sur metabase-audit-collector.
  6. Cliquez sur l'onglet Journaux.

  7. Vérifiez que la fonction s'est exécutée correctement. Par exemple :

    Fetching logs from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00
Table audit_log: fetched X records
Table view_log: fetched X records
Table query_execution: fetched X records
Wrote X records to gs://metabase-audit-logs/metabase-audit/metabase_audit_YYYYMMDD_HHMMSS.ndjson
Successfully processed X records

  8. Accédez à Cloud Storage > Buckets.

  9. Cliquez sur metabase-audit-logs.

  10. Accédez au dossier metabase-audit/.

  11. Vérifiez qu'un nouveau fichier .ndjson a été créé avec l'horodatage actuel.

Si des erreurs s'affichent dans les journaux :

  • HTTP 401 : vérifiez que la variable d'environnement METABASE_API_KEY est correcte et que la clé n'a pas été supprimée ni régénérée.
  • HTTP 403 : vérifiez que le groupe de la clé API dispose des autorisations d'interrogation pour la base de données de l'application.
  • HTTP 429 : limitation du débit. La fonction arrête la pagination et la reprend lors de la prochaine exécution planifiée.
  • Variables d'environnement manquantes : vérifiez que toutes les variables requises sont définies dans la configuration de la fonction Cloud Run.
  • Résultats vides : vérifiez que DATABASE_ID est correct, que la base de données de l'application est ajoutée en tant que source de données et que vous utilisez Metabase Pro ou Enterprise.

Récupérer le compte de service Google SecOps

  1. Accédez à Paramètres SIEM> Flux.
  2. Cliquez sur Ajouter un flux.
  3. Cliquez sur Configurer un flux unique.
  4. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Metabase Audit Logs).
  5. Sélectionnez Google Cloud Storage V2 comme Type de source.
  6. Sélectionnez METABASE comme type de journal.

  7. Cliquez sur 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 au préfixe :

      gs://metabase-audit-logs/metabase-audit/

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

      • Jamais : ne supprime jamais aucun fichier après les transferts (recommandé pour les tests).
      • Supprimer les fichiers transférés : supprime les fichiers une fois le 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 des derniers jours (180 jours par défaut).

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

    • Libellés d'ingestion : libellé à appliquer aux événements de ce flux

  11. Cliquez sur Suivant.

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

Accorder des autorisations IAM au compte de service Google SecOps

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

  1. Accédez à Cloud Storage > Buckets.
  2. Cliquez sur metabase-audit-logs.
  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.

Tables d'analyse de l'utilisation

La fonction Cloud Run interroge les tables suivantes de la base de données de l'application Metabase :

Nom de la table Description
audit_log Enregistrements des modifications de configuration, des actions des utilisateurs et des événements système
view_log Suivre les vues des fiches (questions/modèles), des tableaux de bord et des tableaux
query_execution Informations sur toutes les requêtes exécutées dans tous les tableaux de bord

Conservation des données

Par défaut, Metabase conserve les données d'analyse de l'utilisation pendant 720 jours (environ deux ans). Deux fois par jour, Metabase supprime automatiquement les lignes antérieures à ce seuil. Pour modifier la période de conservation, définissez la variable d'environnement MB_AUDIT_MAX_RETENTION_DAYS lorsque vous exécutez Metabase.

Table de mappage UDM

Champ de journal Mappage UDM Logique
supplémentaires supplémentaires Renommé depuis "Supplémentaire"
locale additional.fields Fusionné avec les libellés respectifs (par exemple, locale_label pour le paramètre régional, is_active_label pour is_active, etc.)
is_active additional.fields
is_qbnewb additional.fields
group_ids additional.fields
is_superuser additional.fields
login_attributes additional.fields
id additional.fields
sso_source additional.fields
personal_collection_id additional.fields
métadonnées métadonnées Renommé à partir des métadonnées
updated_at metadata.event_timestamp Date analysée à partir de "updated_at" à l'aide d'ISO8601, RFC 3339 ou yyyy-MM-ddTHH:mm:ss.SSSSSSZ
has_userid metadata.event_type Définissez sur "USER_UNCATEGORIZED" si has_userid == "true", sinon "GENERIC_EVENT"
principal principal Renommé à partir du compte principal
metabase_host principal.url Valeur copiée directement
date_joined principal.user.attribute.creation_time Date analysée à partir de date_joined à l'aide des formats ISO8601, RFC 3339 ou yyyy-MM-ddTHH:mm:ss.SSSSSSZ
e-mail principal.user.email_addresses Fusionné à partir d'une adresse e-mail
first_name principal.user.first_name Valeur copiée directement
last_login principal.user.last_login_time Date analysée à partir de last_login à l'aide d'ISO8601, RFC 3339 ou yyyy-MM-ddTHH:mm:ss.SSSSSSZ
last_name principal.user.last_name Valeur copiée directement
common_name principal.user.user_display_name Valeur copiée directement
e-mail principal.user.userid Valeur copiée directement depuis l'e-mail
security_result security_result Fusionné à partir de security_result
cible cible Renommé à partir de la cible
metadata.product_name metadata.product_name Défini sur "METABASE"
metadata.vendor_name metadata.vendor_name Défini sur "METABASE"

Journal des modifications

Afficher le journal des modifications pour ce parseur

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