Collecter les journaux Atlassian Confluence

Compatible avec :

Ce document explique comment ingérer des journaux Atlassian Confluence dans Google Security Operations. L'analyseur tente d'abord d'extraire les champs du message de journal brut à l'aide d'expressions régulières (modèles Grok) conçues pour les journaux Atlassian Confluence. Si l'analyse grok échoue ou si le journal est au format JSON, le code tente ensuite d'analyser le message au format JSON. Enfin, les champs extraits sont mappés au schéma UDM Google SecOps et enrichis avec un contexte supplémentaire.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

  • Une instance Google SecOps
  • Compte Atlassian Confluence Cloud avec accès aux journaux d'audit OU compte Confluence Data Center/Server avec accès administrateur
  • Pour les méthodes basées sur AWS : accès privilégié à AWS (S3, IAM, Lambda, EventBridge)
  • Pour la méthode Bindplane : hôte Windows 2016 ou version ultérieure, ou hôte Linux avec systemd

Présentation des options d'intégration

Ce guide propose deux méthodes d'intégration :

  • Option 1 : Confluence Data Center/Server via BindPlane + Syslog
  • Option 2 : Journaux d'audit Confluence Cloud via AWS Lambda + S3 (format JSON)

Choisissez l'option qui correspond le mieux à votre type de déploiement et à votre infrastructure Confluence.

Option 1 : Confluence Data Center/Server via Bindplane + Syslog

Cette option configure Confluence Data Center ou Server pour envoyer des journaux via syslog à un agent Bindplane, qui les transmet ensuite à Google SecOps.

Obtenir le fichier d'authentification d'ingestion Google SecOps

  1. Connectez-vous à la console Google SecOps.
  2. Accédez à Paramètres du SIEM > Agents de collecte.
  3. Téléchargez le fichier d'authentification d'ingestion. Enregistrez le fichier de manière sécurisée sur le système sur lequel Bindplane sera installé.

Obtenir l'ID client Google SecOps

  1. Connectez-vous à la console Google SecOps.
  2. Accédez à Paramètres SIEM> Profil.
  3. Copiez et enregistrez le numéro client de la section Informations sur l'organisation.

Installer l'agent Bindplane

Installez l'agent Bindplane sur votre système d'exploitation Windows ou Linux en suivant les instructions ci-dessous.

Installation de fenêtres

  1. Ouvrez l'invite de commandes ou PowerShell en tant qu'administrateur.

  2. Exécutez la commande suivante :

    msiexec /i "https://github.com/observIQ/bindplane-agent/releases/latest/download/observiq-otel-collector.msi" /quiet

Installation de Linux

  1. Ouvrez un terminal avec les droits root ou sudo.

  2. Exécutez la commande suivante :

    sudo sh -c "$(curl -fsSlL https://github.com/observiq/bindplane-agent/releases/latest/download/install_unix.sh)" install_unix.sh

Autres ressources d'installation

Configurer l'agent Bindplane pour ingérer Syslog et l'envoyer à Google SecOps

  1. Accédez au fichier de configuration :

    1. Recherchez le fichier config.yaml. Il se trouve généralement dans le répertoire /etc/bindplane-agent/ sous Linux ou dans le répertoire d'installation sous Windows.
    2. Ouvrez le fichier à l'aide d'un éditeur de texte (par exemple, nano, vi ou le Bloc-notes).

  2. Modifiez le fichier config.yaml comme suit :

    receivers:
  udplog:
    # Replace the port and IP address as required
    listen_address: "0.0.0.0:514"

exporters:
  chronicle/chronicle_w_labels:
    compression: gzip
    # Adjust the path to the credentials file you downloaded
    creds_file_path: '/path/to/ingestion-authentication-file.json'
    # Replace with your actual customer ID
    customer_id: YOUR_CUSTOMER_ID
    endpoint: malachiteingestion-pa.googleapis.com
    log_type: 'ATLASSIAN_CONFLUENCE'
    raw_log_field: body
    ingestion_labels:

service:
  pipelines:
    logs/confluence:
      receivers:
        - udplog
      exporters:
        - chronicle/chronicle_w_labels
    • Remplacez le port et l'adresse IP selon les besoins de votre infrastructure.
    • Remplacez <YOUR_CUSTOMER_ID_HERE> par le numéro client réel.
    • Mettez à jour /path/to/ingestion-authentication-file.json en indiquant le chemin d'accès où le fichier d'authentification a été enregistré dans la section Obtenir le fichier d'authentification pour l'ingestion Google SecOps.

Redémarrez l'agent Bindplane pour appliquer les modifications.

  • Pour redémarrer l'agent Bindplane sous Linux, exécutez la commande suivante :

    sudo systemctl restart bindplane-agent

  • Pour redémarrer l'agent Bindplane sous Windows, vous pouvez utiliser la console Services ou saisir la commande suivante :

    net stop BindPlaneAgent && net start BindPlaneAgent

Configurer le transfert Syslog sur Confluence Data Center/Server

  1. Connectez-vous à votre serveur Confluence via SSH ou RDP.
  2. Localisez le fichier de configuration Log4j :
    • Pour Log4j2 : <confluence-install>/confluence/WEB-INF/classes/log4j2.xml

  3. Modifiez le fichier de configuration pour ajouter un SyslogAppender :

    <Configuration>
  <Appenders>
    <!-- Existing appenders -->

    <Syslog name="SyslogAppender" 
            host="BINDPLANE_AGENT_IP" 
            port="514" 
            protocol="UDP"
            facility="LOCAL0"
            format="RFC5424">
      <PatternLayout pattern="%d{ISO8601} %p [%t] [%c{1}] %m%n"/>
    </Syslog>
  </Appenders>

  <Loggers>
    <Root level="info">
      <AppenderRef ref="SyslogAppender"/>
      <!-- Other appender refs -->
    </Root>

    <!-- Audit logger -->
    <Logger name="com.atlassian.confluence.event.events.security.AuditEvent" level="info" additivity="false">
      <AppenderRef ref="SyslogAppender"/>
    </Logger>
  </Loggers>
</Configuration>
    • Remplacez BINDPLANE_AGENT_IP par l'adresse IP de votre agent BindPlane.

  4. Redémarrez Confluence pour appliquer les modifications :

    sudo systemctl restart confluence

Option B : Configurer rsyslog pour transférer les fichiers journaux locaux

  1. Configurez Confluence pour qu'il écrive les journaux dans des fichiers (comportement par défaut).

  2. Installez rsyslog si ce n'est pas déjà fait :

    sudo apt-get install rsyslog  # Debian/Ubuntu
sudo yum install rsyslog      # RHEL/CentOS

  3. Créez le fichier de configuration rsyslog /etc/rsyslog.d/confluence.conf :

    # Forward Confluence logs to BindPlane
$ModLoad imfile

# Application logs
$InputFileName /opt/atlassian/confluence/logs/atlassian-confluence.log
$InputFileTag confluence-app:
$InputFileStateFile stat-confluence-app
$InputFileSeverity info
$InputFileFacility local0
$InputRunFileMonitor

# Audit logs (JSON format in DC/Server)
$InputFileName /var/atlassian/application-data/confluence/log/audit/*.json
$InputFileTag confluence-audit:
$InputFileStateFile stat-confluence-audit
$InputFileSeverity info
$InputFileFacility local1
$InputRunFileMonitor

# Forward to BindPlane agent
*.* @@BINDPLANE_AGENT_IP:514
    • Remplacez BINDPLANE_AGENT_IP par l'adresse IP de votre agent Bindplane.
    • Ajustez les chemins d'accès aux fichiers journaux en fonction de votre installation Confluence :
      • Journaux d'application : <confluence-install>/logs/ ou <local-home>/logs/
      • Journaux d'audit : <confluence-home>/log/audit/*.json

  4. Redémarrez rsyslog :

    sudo systemctl restart rsyslog

Option 2 : Journaux d'audit Confluence Cloud via AWS Lambda + S3

Collecter les identifiants de l'API Confluence Cloud

  1. Connectez-vous à votre compte Atlassian.
  2. Accédez à https://id.atlassian.com/manage-profile/security/api-tokens.
  3. Cliquez sur Create API token (Créer un jeton d'API).
  4. Saisissez un libellé pour le jeton (par exemple, Google Security Operations Integration).
  5. Cliquez sur Créer.
  6. Copiez et enregistrez le jeton d'API de manière sécurisée.
  7. Notez l'URL de votre site Confluence Cloud (par exemple, https://yoursite.atlassian.net).
  8. Notez l'adresse e-mail de votre compte Atlassian (utilisée pour l'authentification).

Configurer un bucket AWS S3 et IAM pour Google SecOps

  1. Créez un bucket Amazon S3 en suivant ce guide de l'utilisateur : Créer un bucket.
  2. Enregistrez le nom et la région du bucket pour référence ultérieure (par exemple, confluence-audit-logs).
  3. Créez un utilisateur en suivant ce guide de l'utilisateur : Créer un utilisateur IAM.
  4. Sélectionnez l'utilisateur créé.
  5. Sélectionnez l'onglet Informations d'identification de sécurité.
  6. Cliquez sur Créer une clé d'accès dans la section Clés d'accès.
  7. Sélectionnez Service tiers comme Cas d'utilisation.
  8. Cliquez sur Suivant.
  9. Facultatif : Ajoutez un tag de description.
  10. Cliquez sur Créer une clé d'accès.
  11. Cliquez sur Télécharger le fichier CSV pour enregistrer la clé d'accès et la clé d'accès secrète pour référence ultérieure.
  12. Cliquez sur OK.
  13. Sélectionnez l'onglet Autorisations.
  14. Cliquez sur Ajouter des autorisations dans la section Règles relatives aux autorisations.
  15. Sélectionnez Ajouter des autorisations.
  16. Sélectionnez Joindre directement des règles.
  17. Recherchez la règle AmazonS3FullAccess.
  18. Sélectionnez la règle.
  19. Cliquez sur Suivant.
  20. Cliquez sur Ajouter des autorisations.

Configurer la stratégie et le rôle IAM pour les importations S3

  1. Dans la console AWS, accédez à IAM > Policies > Create policy > onglet JSON.

  2. Saisissez la règle suivante : 

    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowPutObjects",
      "Effect": "Allow",
      "Action": "s3:PutObject",
      "Resource": "arn:aws:s3:::confluence-audit-logs/*"
    },
    {
      "Sid": "AllowGetStateObject",
      "Effect": "Allow",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::confluence-audit-logs/confluence-audit/state.json"
    }
  ]
}
    • Remplacez confluence-audit-logs si vous avez saisi un autre nom de bucket.

  3. Cliquez sur Suivant > Créer une règle.

  4. Nommez la règle ConfluenceAuditToS3Policy.

  5. Accédez à IAM > Rôles > Créer un rôle > Service AWS > Lambda.

  6. Associez la règle que vous venez de créer ConfluenceAuditToS3Policy.

  7. Nommez le rôle ConfluenceAuditLambdaRole, puis cliquez sur Créer un rôle.

Créer la fonction Lambda

  1. Dans la console AWS, accédez à Lambda > Functions.
  2. Cliquez sur Créer une fonction> Créer à partir de zéro.

  3. Fournissez les informations de configuration suivantes :

    Paramètre Valeur
    Nom ConfluenceAuditToS3
    Durée d'exécution Python 3.13
    Architecture x86_64
    Rôle d'exécution ConfluenceAuditLambdaRole

  4. Une fois la fonction créée, ouvrez l'onglet Code, supprimez le stub et saisissez le code suivant :

    import json
import os
import boto3
from datetime import datetime, timezone, timedelta
from urllib import request, parse, error
from base64 import b64encode

# Environment variables
S3_BUCKET = os.environ['S3_BUCKET']
S3_PREFIX = os.environ.get('S3_PREFIX', 'confluence-audit/')
STATE_KEY = os.environ.get('STATE_KEY', 'confluence-audit/state.json')
CONFLUENCE_URL = os.environ['CONFLUENCE_URL']  # e.g., https://yoursite.atlassian.net
CONFLUENCE_EMAIL = os.environ['CONFLUENCE_EMAIL']
CONFLUENCE_API_TOKEN = os.environ['CONFLUENCE_API_TOKEN']
MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '1000'))

s3_client = boto3.client('s3')

def lambda_handler(event, context):
    """Fetch Confluence Cloud audit logs and write to S3."""

    # Read last execution state
    start_date = get_last_execution_time()
    end_date = datetime.now(timezone.utc)

    print(f"Fetching audit logs from {start_date} to {end_date}")

    # Fetch audit records
    records = fetch_audit_logs(start_date, end_date)

    if not records:
        print("No new audit records found.")
        save_state(end_date)
        return {'statusCode': 200, 'body': 'No new records'}

    # Write to S3
    timestamp = end_date.strftime('%Y%m%d_%H%M%S')
    object_key = f"{S3_PREFIX}audit_{timestamp}.json"

    s3_client.put_object(
        Bucket=S3_BUCKET,
        Key=object_key,
        Body='\n'.join(json.dumps(record) for record in records),
        ContentType='application/json'
    )

    print(f"Wrote {len(records)} records to s3://{S3_BUCKET}/{object_key}")

    # Update state
    save_state(end_date)

    return {
        'statusCode': 200,
        'body': f"Processed {len(records)} records"
    }

def get_last_execution_time():
    """Retrieve the last execution timestamp from S3 state file."""
    try:
        response = s3_client.get_object(Bucket=S3_BUCKET, Key=STATE_KEY)
        state = json.loads(response['Body'].read())
        return datetime.fromisoformat(state['last_execution'])
    except s3_client.exceptions.NoSuchKey:
        # First run: fetch logs from last 24 hours
        return datetime.now(timezone.utc) - timedelta(hours=24)
    except Exception as e:
        print(f"Error reading state: {e}")
        return datetime.now(timezone.utc) - timedelta(hours=24)

def save_state(execution_time):
    """Save the execution timestamp to S3 state file."""
    state = {'last_execution': execution_time.isoformat()}
    s3_client.put_object(
        Bucket=S3_BUCKET,
        Key=STATE_KEY,
        Body=json.dumps(state),
        ContentType='application/json'
    )

def fetch_audit_logs(start_date, end_date):
    """Fetch audit logs from Confluence Cloud REST API."""
    records = []
    start_param = int(start_date.timestamp() * 1000)  # milliseconds
    end_param = int(end_date.timestamp() * 1000)

    # Build authentication header
    auth_string = f"{CONFLUENCE_EMAIL}:{CONFLUENCE_API_TOKEN}"
    auth_bytes = auth_string.encode('ascii')
    auth_b64 = b64encode(auth_bytes).decode('ascii')

    headers = {
        'Authorization': f'Basic {auth_b64}',
        'Accept': 'application/json'
    }

    # Confluence Cloud Audit API endpoint
    url = f"{CONFLUENCE_URL}/wiki/rest/api/audit?startDate={start_param}&endDate={end_param}&limit=1000"

    try:
        req = request.Request(url, headers=headers)
        with request.urlopen(req) as response:
            data = json.loads(response.read())
            records = data.get('results', [])
            print(f"Retrieved {len(records)} audit records")
    except error.HTTPError as e:
        print(f"HTTP Error: {e.code} - {e.reason}")
        print(e.read().decode())
    except Exception as e:
        print(f"Error fetching audit logs: {e}")

    return records[:MAX_RECORDS]

  5. Accédez à Configuration > Variables d'environnement.

  6. Cliquez sur Modifier > Ajouter une variable d'environnement.

  7. Saisissez les variables d'environnement suivantes en remplaçant par vos valeurs.

    Clé Exemple de valeur
    S3_BUCKET confluence-audit-logs
    S3_PREFIX confluence-audit/
    STATE_KEY confluence-audit/state.json
    CONFLUENCE_URL https://yoursite.atlassian.net
    CONFLUENCE_EMAIL your-email@example.com
    CONFLUENCE_API_TOKEN your-api-token-here
    MAX_RECORDS 1000

  8. Accédez à l'onglet Configuration.

  9. Dans le panneau Configuration générale, cliquez sur Modifier.

  10. Définissez Délai avant expiration sur 5 minutes (300 secondes), puis cliquez sur Enregistrer.

Créer une programmation EventBridge

  1. Accédez à Amazon EventBridge> Scheduler> Create schedule.
  2. Fournissez les informations de configuration suivantes :
    • Planification récurrente : Tarif (1 hour).
    • Cible : votre fonction Lambda ConfluenceAuditToS3.
    • Nom : ConfluenceAuditToS3-1h.
  3. Cliquez sur Créer la programmation.

Facultatif : Créez un utilisateur et des clés IAM en lecture seule pour Google SecOps

  1. Accédez à la console AWS > IAM > Utilisateurs.
  2. Cliquez sur Add users (Ajouter des utilisateurs).
  3. Fournissez les informations de configuration suivantes :
    • Utilisateur : saisissez secops-confluence-reader.
    • Type d'accès : sélectionnez Clé d'accès – Accès programmatique.
  4. Cliquez sur Suivant.
  5. Cliquez sur Associer directement des règles > Créer une règle.

  6. Dans l'éditeur JSON, saisissez la stratégie suivante :

    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject"],
      "Resource": "arn:aws:s3:::confluence-audit-logs/*"
    },
    {
      "Effect": "Allow",
      "Action": ["s3:ListBucket"],
      "Resource": "arn:aws:s3:::confluence-audit-logs"
    }
  ]
}

  7. Définissez le nom sur secops-reader-policy.

  8. Accédez à Créer une règle > recherchez/sélectionnez > Suivant > Ajouter des autorisations.

  9. Accédez à Identifiants de sécurité> Clés d'accès> Créer une clé d'accès.

  10. Téléchargez le CSV (ces valeurs sont saisies dans le flux).

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

  1. Accédez à Paramètres SIEM> Flux.
  2. Cliquez sur Add New Feed (Ajouter un flux).
  3. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Confluence Cloud Audit Logs).
  4. Sélectionnez Amazon S3 V2 comme type de source.
  5. Sélectionnez Atlassian Confluence comme Type de journal.
  6. Cliquez sur Suivant.
  7. Spécifiez les valeurs des paramètres d'entrée suivants :
    • URI S3 : s3://confluence-audit-logs/confluence-audit/
    • Options de suppression de la source : sélectionnez l'option de suppression de votre choix.
    • Âge maximal des fichiers : incluez les fichiers modifiés au cours des derniers jours. La valeur par défaut est de 180 jours.
    • ID de clé d'accès : clé d'accès utilisateur ayant accès au bucket S3.
    • Clé d'accès secrète : clé secrète de l'utilisateur ayant accès au bucket S3.
    • Espace de noms de l'élément : espace de noms de l'élément.
    • Libellés d'ingestion : libellé appliqué aux événements de ce flux.
  8. Cliquez sur Suivant.
  9. Vérifiez la configuration de votre nouveau flux sur l'écran Finaliser, puis cliquez sur Envoyer.

Table de mappage UDM

Champ de journal Mappage UDM Logique
agent read_only_udm.network.http.user_agent Valeur extraite du champ "agent".
app_protocol read_only_udm.network.application_protocol Dérivé du champ "app_protocol". Si "app_protocol" contient "HTTPS", "HTTP", "SSH" ou "RDP", le protocole correspondant est utilisé. Sinon, la valeur par défaut est "UNKNOWN_APPLICATION_PROTOCOL".
app_protocol read_only_udm.network.application_protocol_version Valeur extraite du champ "app_protocol".
auditType.action read_only_udm.security_result.action Dérivé du champ "auditType.action". Si "auditType.action" contient "successful", la valeur est définie sur "ALLOW". Si elle contient "restricted" (restreint), la valeur est définie sur "BLOCK" (BLOQUER).
auditType.action read_only_udm.security_result.summary Valeur extraite du champ "auditType.action" lorsque "auditType" n'est pas vide et que "auditType_area" est défini sur "SECURITY".
auditType.actionI18nKey read_only_udm.metadata.product_event_type Valeur extraite du champ "auditType.actionI18nKey" lorsque "auditType" n'est pas vide.
auditType.area read_only_udm.security_result.detection_fields.value Valeur extraite du champ "auditType.area" et attribuée au champ "value" d'un champ de détection dont le champ "key" est défini sur "auditType area". Ce mappage est effectué lorsque "auditType" n'est pas vide.
auditType.category read_only_udm.security_result.category_details Valeur extraite du champ "auditType.category" lorsque "auditType" n'est pas vide.
auditType.categoryI18nKey read_only_udm.security_result.detection_fields.value Valeur extraite du champ "auditType.categoryI18nKey" et attribuée au champ "value" d'un champ de détection dont le champ "key" est défini sur "auditType categoryI18nKey". Ce mappage est effectué lorsque "auditType" n'est pas vide.
auditType.level read_only_udm.security_result.detection_fields.value Valeur extraite du champ "auditType.level" et attribuée au champ "value" d'un champ de détection dont le champ "key" est défini sur "auditType level". Ce mappage est effectué lorsque "auditType" n'est pas vide.
author.displayName read_only_udm.principal.user.user_display_name Valeur extraite du champ "author.displayName".
author.externalCollaborator read_only_udm.security_result.about.resource.attribute.labels.value Valeur extraite du champ "author.externalCollaborator" et attribuée au champ "value" d'un libellé dont le champ "key" est défini sur "externalCollaborator".
author.id read_only_udm.principal.user.userid Valeur extraite du champ "author.id" lorsque "author.type" est défini sur "user" et "principal_user_present" sur "false".
author.isExternalCollaborator read_only_udm.security_result.about.resource.attribute.labels.value Valeur extraite du champ "author.isExternalCollaborator" et attribuée au champ "value" d'un libellé dont le champ "key" est défini sur "isExternalCollaborator".
author.name read_only_udm.principal.user.user_display_name Valeur extraite du champ "author.name" lorsque "author.type" est défini sur "user" et "principal_user_present" sur "false".
bytes_in read_only_udm.network.received_bytes Valeur extraite du champ "bytes_in" s'il contient des chiffres. Sinon, la valeur par défaut est 0.
category read_only_udm.security_result.category_details Valeur extraite du champ "category" (catégorie).
changedValues read_only_udm.principal.resource.attribute.labels Parcourt chaque élément de "changedValues" et crée des libellés avec des clés telles que "changedValue[index][key]" et des valeurs issues des valeurs correspondantes du tableau "changedValues".
date de création read_only_udm.metadata.event_timestamp Valeur extraite du champ "creationDate", analysée en tant qu'horodatage UNIX ou UNIX_MS.
extraAttributes read_only_udm.principal.resource.attribute.labels Parcourt chaque élément de "extraAttributes" et crée des libellés avec des clés basées sur les champs "name" et "nameI18nKey", et des valeurs issues du champ "value" correspondant.
http_verb read_only_udm.network.http.method Valeur extraite du champ "http_verb".
ip read_only_udm.target.ip Valeur extraite du champ "ip".
principal_host read_only_udm.principal.hostname Valeur extraite du champ "principal_host".
referral_url read_only_udm.network.http.referral_url Valeur extraite du champ "referral_url".
remoteAddress read_only_udm.principal.ip Valeur extraite du champ "remoteAddress", analysée en tant qu'adresse IP.
response_code read_only_udm.network.http.response_code Valeur extraite du champ "response_code".
session_duration read_only_udm.additional.fields.value.string_value Valeur extraite du champ "session_duration" et attribuée au champ "string_value" d'un libellé dont le champ "key" est défini sur "Session Duration" (Durée de la session).
source read_only_udm.principal.ip Valeur extraite du champ "source" et analysée en tant qu'adresse IP.
src_ip read_only_udm.principal.ip Valeur extraite du champ "src_ip" si "remoteAddress" est vide.
résumé read_only_udm.security_result.summary Valeur extraite du champ "summary" (résumé).
sysAdmin read_only_udm.security_result.about.resource.attribute.labels.value Valeur extraite du champ "sysAdmin" et attribuée au champ "value" d'un libellé dont le champ "key" est défini sur "sysAdmin".
superAdmin read_only_udm.security_result.about.resource.attribute.labels.value Valeur extraite du champ "superAdmin" et attribuée au champ "value" d'un libellé dont le champ "key" est défini sur "superAdmin".
target_url read_only_udm.target.url Valeur extraite du champ "target_url".
timestamp read_only_udm.metadata.event_timestamp Valeur extraite du champ "timestamp", analysée sous forme de chaîne de date et d'heure.
user_id read_only_udm.principal.user.userid Valeur extraite du champ "user_id".
read_only_udm.metadata.event_type La valeur de ce champ est déterminée par une série de vérifications et est définie par défaut sur "GENERIC_EVENT". Elle est définie sur des valeurs spécifiques telles que "NETWORK_HTTP", "USER_UNCATEGORIZED" ou "STATUS_UPDATE" en fonction de la présence et du contenu d'autres champs tels que "principal_host", "user_id", "has_principal" et "author.type".
read_only_udm.metadata.vendor_name Défini sur "ATLASSIAN".
read_only_udm.metadata.product_name Définissez-le sur "CONFLUENCE".
read_only_udm.metadata.log_type Définissez-le sur "ATLASSIAN_CONFLUENCE".
read_only_udm.principal.user.user_display_name La valeur de ce champ peut provenir de "author.displayName" ou de "affectedObject.name", selon le contexte.
read_only_udm.target.process.pid La valeur de ce champ peut provenir de "principal_host" ou de "pid" selon le contexte.
read_only_udm.principal.resource.attribute.labels Ce champ est renseigné avec différents libellés dérivés de champs tels que "affectedObjects", "changedValues" et "extraAttributes". Les clés et les valeurs de ces libellés sont générées de manière dynamique en fonction du contenu spécifique de ces champs.

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