收集 Talon 記錄

支援的國家/地區：

本文說明如何使用 Google Cloud Storage V2，將 Talon 記錄檔擷取至 Google Security Operations。

Talon (現為 Palo Alto Networks 的一部分) 是企業瀏覽器安全平台，可為受管理和不受管理的裝置提供安全瀏覽、資料遺失防護 (DLP) 和存取權控管功能。收購後，Talon 已整合至 Prisma Access 平台，成為 Prisma Access Browser，並透過 Strata Logging Service 轉送記錄。Strata Logging Service API 提供以程式輔助方式存取安全性事件記錄的權限。

事前準備

請確認您已完成下列事前準備事項：

  • Google SecOps 執行個體
  • 已啟用 Cloud Storage API 的 GCP 專案
  • 建立及管理 GCS bucket 的權限
  • 管理 Google Cloud Storage 值區 IAM 政策的權限
  • 建立 Cloud Run 服務、Pub/Sub 主題和 Cloud Scheduler 工作的權限
  • 具備管理員權限的 Strata Cloud Manager 特殊存取權
  • Palo Alto Networks Hub 的 OAuth2 用戶端憑證 (用戶端 ID、用戶端密鑰和 TSG ID)

建立 Google Cloud Storage 值區

  1. 前往 Google Cloud Console。
  2. 選取專案或建立新專案。
  3. 在導覽選單中，依序前往「Cloud Storage」>「Bucket」。
  4. 按一下「建立值區」。

  5. 請提供下列設定詳細資料：

    設定 值
    為 bucket 命名 輸入全域不重複的名稱 (例如 talon-logs)
    位置類型 根據需求選擇 (區域、雙區域、多區域)
    位置 選取位置 (例如 us-central1)
    儲存空間級別 標準 (建議用於經常存取的記錄)
    存取控管 統一 (建議)
    保護工具 選用：啟用物件版本管理或資料保留政策

  6. 點選「建立」。

收集 Talon API 憑證

建立 OAuth2 用戶端憑證

  1. 登入 Palo Alto Networks Hub。
  2. 依序前往「設定」>「服務帳戶」。
  3. 按一下 [新增服務帳戶]。
  4. 請提供下列設定詳細資料：
    • 名稱：輸入描述性名稱 (例如 Google SecOps Talon Integration)。
    • 角色：選取具有記錄讀取權的角色。
  5. 按一下「新增」。
  6. 複製下列詳細資料並儲存到安全位置：
    • 用戶端 ID：OAuth2 用戶端 ID
    • 用戶端密鑰：OAuth2 用戶端密鑰

  7. 從 Hub 網址或「設定」頁面記下租戶服務群組 (TSG) ID。

判斷 API 基準網址

Strata Logging Service API 基本網址：

區域 API 基礎網址
全球 https://api.strata.paloaltonetworks.com

測試 API 存取權

  • 請先測試憑證，再繼續進行整合：

    # Replace with your actual credentials
CLIENT_ID="your-client-id"
CLIENT_SECRET="your-client-secret"
TSG_ID="your-tsg-id"

# Get access token
curl -s -X POST "https://auth.apps.paloaltonetworks.com/oauth2/access_token" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=client_credentials&scope=tsg_id:${TSG_ID}" \
  -u "${CLIENT_ID}:${CLIENT_SECRET}"

為 Cloud Run 函式建立服務帳戶

Cloud Run 函式需要具備 GCS bucket 寫入權限的服務帳戶，並由 Pub/Sub 叫用。

建立服務帳戶

  1. 在 GCP 控制台中，依序前往「IAM 與管理」>「服務帳戶」。
  2. 按一下「Create Service Account」(建立服務帳戶)。
  3. 請提供下列設定詳細資料：
    • 服務帳戶名稱：輸入 talon-logs-collector-sa
    • 服務帳戶說明：輸入 Service account for Cloud Run function to collect Talon logs
  4. 按一下「建立並繼續」。
  5. 在「將專案存取權授予這個服務帳戶」部分，新增下列角色：
    1. 按一下「選擇角色」。
    2. 搜尋並選取「Storage 物件管理員」。
    3. 點選「+ 新增其他角色」。
    4. 搜尋並選取「Cloud Run Invoker」。
    5. 點選「+ 新增其他角色」。
    6. 搜尋並選取「Cloud Functions Invoker」(Cloud Functions 叫用者)。
  6. 按一下「繼續」。
  7. 按一下 [完成]。

這些角色適用於：

  • Storage 物件管理員：將記錄檔寫入 GCS bucket，並管理狀態檔案
  • Cloud Run 叫用者：允許 Pub/Sub 叫用函式
  • Cloud Functions 叫用者：允許函式叫用

授予 GCS 值區的 IAM 權限

授予服務帳戶 GCS bucket 的寫入權限：

  1. 依序前往「Cloud Storage」>「Buckets」。
  2. 按一下 bucket 名稱 (例如 talon-logs)。
  3. 前往「權限」分頁標籤。
  4. 按一下「授予存取權」。
  5. 請提供下列設定詳細資料：
    • 新增主體：輸入服務帳戶電子郵件地址 (例如 talon-logs-collector-sa@PROJECT_ID.iam.gserviceaccount.com)
    • 指派角色：選取「Storage 物件管理員」
  6. 按一下 [儲存]。

建立 Pub/Sub 主題

建立 Pub/Sub 主題，供 Cloud Scheduler 發布訊息，以及 Cloud Run 函式訂閱訊息。

  1. 在 GCP Console 中，前往「Pub/Sub」>「Topics」(主題)。
  2. 按一下「建立主題」。
  3. 請提供下列設定詳細資料：
    • 主題 ID：輸入 talon-logs-trigger
    • 其他設定保留預設值
  4. 點選「建立」。

建立 Cloud Run 函式來收集記錄

Cloud Run 函式會由 Cloud Scheduler 的 Pub/Sub 訊息觸發，從 Strata Logging Service API 擷取記錄，並寫入 GCS。

  1. 前往 GCP Console 的「Cloud Run」。
  2. 按一下「Create service」(建立服務)。
  3. 選取「函式」 (使用內嵌編輯器建立函式)。

  4. 在「設定」部分，提供下列設定詳細資料：

    設定 值
    服務名稱 talon-logs-collector
    區域 選取與 GCS bucket 相符的區域 (例如 us-central1)
    執行階段 選取 Python 3.12 以上版本

  5. 在「Trigger (optional)」(觸發條件 (選用)) 專區：

    1. 按一下「+ 新增觸發條件」。
    2. 選取「Cloud Pub/Sub」。
    3. 在「選取 Cloud Pub/Sub 主題」中，選擇主題 talon-logs-trigger。
    4. 按一下 [儲存]。

  6. 在「Authentication」(驗證) 部分：

    1. 選取「需要驗證」。
    2. 檢查 Identity and Access Management (IAM)。

  7. 向下捲動並展開「Containers, Networking, Security」。

  8. 前往「安全性」分頁：

    • 服務帳戶：選取服務帳戶 talon-logs-collector-sa。

  9. 前往「容器」分頁：

    1. 按一下「變數與密鑰」。
    2. 針對每個環境變數，按一下「+ 新增變數」：
    變數名稱 範例值 說明
    GCS_BUCKET talon-logs GCS bucket 名稱
    GCS_PREFIX talon 記錄檔的前置字串
    STATE_KEY talon/state.json 狀態檔案路徑
    CLIENT_ID your-client-id OAuth2 用戶端 ID
    CLIENT_SECRET your-client-secret OAuth2 用戶端密鑰
    TSG_ID your-tsg-id 租戶服務群組 ID
    API_BASE_URL https://api.strata.paloaltonetworks.com Strata Logging Service API 基本網址
    MAX_RECORDS 5000 每次執行的記錄數上限
    PAGE_SIZE 1000 每頁記錄數
    LOOKBACK_HOURS 24 初始回溯期

  10. 在「變數與密鑰」部分，向下捲動至「要求」：

    • 要求逾時：輸入 600 秒 (10 分鐘)

  11. 前往「設定」分頁：

    • 在「資源」部分：
      • 記憶體：選取 512 MiB 以上
      • CPU：選取 1

  12. 在「修訂版本資源調度」部分：

    • 執行個體數量下限：輸入 0
    • 「執行個體數量上限」：輸入 100 (或根據預期負載調整)

  13. 點選「建立」。

  14. 等待服務建立完成 (1 到 2 分鐘)。

  15. 服務建立完成後，系統會自動開啟內嵌程式碼編輯器。

新增函式程式碼

  1. 在「進入點」欄位中輸入 main。

  2. 在內嵌程式碼編輯器中建立兩個檔案：

    • 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', 'talon')
STATE_KEY = os.environ.get('STATE_KEY', 'talon/state.json')
CLIENT_ID = os.environ.get('CLIENT_ID')
CLIENT_SECRET = os.environ.get('CLIENT_SECRET')
TSG_ID = os.environ.get('TSG_ID')
API_BASE_URL = os.environ.get('API_BASE_URL', 'https://api.strata.paloaltonetworks.com')
MAX_RECORDS = int(os.environ.get('MAX_RECORDS', '5000'))
PAGE_SIZE = int(os.environ.get('PAGE_SIZE', '1000'))
LOOKBACK_HOURS = int(os.environ.get('LOOKBACK_HOURS', '24'))

AUTH_URL = "https://auth.apps.paloaltonetworks.com/oauth2/access_token"

def to_unix_millis(dt: datetime) -> int:
  """Convert datetime to Unix epoch milliseconds."""
  if dt.tzinfo is None:
    dt = dt.replace(tzinfo=timezone.utc)
  dt = dt.astimezone(timezone.utc)
  return int(dt.timestamp() * 1000)

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)

def get_access_token():
  """
  Obtain OAuth2 access token using client credentials grant.
  """
  import base64
  credentials = base64.b64encode(f"{CLIENT_ID}:{CLIENT_SECRET}".encode()).decode()

  headers = {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Authorization': f'Basic {credentials}',
    'Accept': 'application/json'
  }

  body = f"grant_type=client_credentials&scope=tsg_id:{TSG_ID}"

  backoff = 1.0
  for attempt in range(3):
    response = http.request('POST', AUTH_URL, body=body, headers=headers)

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

    if response.status != 200:
      raise RuntimeError(f"Failed to get access token: {response.status} - {response.data.decode('utf-8')}")

    data = json.loads(response.data.decode('utf-8'))
    return data['access_token']

  raise RuntimeError("Failed to get access token after 3 retries")

@functions_framework.cloud_event
def main(cloud_event):
  """
  Cloud Run function triggered by Pub/Sub to fetch Talon
  (Prisma Access Browser) logs and write to GCS.

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

  if not all([GCS_BUCKET, CLIENT_ID, CLIENT_SECRET, TSG_ID]):
    print('Error: Missing required environment variables')
    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_event_time"):
      try:
        last_time = parse_datetime(state["last_event_time"])
        # Overlap by 2 minutes to catch any delayed events
        last_time = last_time - timedelta(minutes=2)
      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 from {last_time.isoformat()} to {now.isoformat()}")

    # Get access token
    token = get_access_token()

    # Fetch logs
    records, newest_event_time = fetch_logs(
      token=token,
      start_time=last_time,
      end_time=now,
      page_size=PAGE_SIZE,
      max_records=MAX_RECORDS,
    )

    if not records:
      print("No new 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 records]) + '\n'
    blob.upload_from_string(ndjson, content_type='application/x-ndjson')

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

    # Update state with newest event time
    if newest_event_time:
      save_state(bucket, STATE_KEY, newest_event_time)
    else:
      save_state(bucket, STATE_KEY, now.isoformat())

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

  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 fetch_logs(token: str, start_time: datetime, end_time: datetime, page_size: int, max_records: int):
  """
  Fetch event logs from Strata Logging Service API
  with pagination and rate limiting.

  Args:
    token: OAuth2 access token
    start_time: Start time for log query
    end_time: End time for log query
    page_size: Number of records per page
    max_records: Maximum total records to fetch

  Returns:
    Tuple of (records list, newest_event_time ISO string)
  """
  api_base = API_BASE_URL.rstrip('/')
  endpoint = f"{api_base}/logging-service/v1/queries"

  headers = {
    'Authorization': f'Bearer {token}',
    'Accept': 'application/json',
    'Content-Type': 'application/json',
    'User-Agent': 'GoogleSecOps-TalonCollector/1.0'
  }

  records = []
  newest_time = None
  page_num = 0
  backoff = 1.0

  # Create log query
  query_body = json.dumps({
    'query': 'SELECT * FROM `firewall.traffic`',
    'startTime': int(start_time.timestamp()),
    'endTime': int(end_time.timestamp()),
    'maxWaitTime': 30000,
    'pageSize': min(page_size, max_records)
  })

  try:
    response = http.request('POST', endpoint, body=query_body, 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)
      response = http.request('POST', endpoint, body=query_body, headers=headers)

    if response.status not in (200, 201):
      print(f"HTTP Error: {response.status}")
      response_text = response.data.decode('utf-8')
      print(f"Response body: {response_text}")
      return [], None

    data = json.loads(response.data.decode('utf-8'))
    query_id = data.get('queryId')
    query_status = data.get('queryStatus', '')

  except Exception as e:
    print(f"Error creating query: {e}")
    return [], None

  # Poll for results
  results_endpoint = f"{api_base}/logging-service/v1/queries/{query_id}/results"
  scroll_token = None

  while True:
    page_num += 1

    if len(records) >= max_records:
      print(f"Reached max_records limit ({max_records})")
      break

    try:
      params = {'pageSize': min(page_size, max_records - len(records))}
      if scroll_token:
        params['scrollToken'] = scroll_token

      url = results_endpoint + '?' + '&'.join(f'{k}={v}' for k, v in params.items())
      response = http.request('GET', url, headers=headers)

      # Handle rate limiting with exponential backoff
      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 == 202:
        print("Query still processing, waiting...")
        time.sleep(5)
        continue

      backoff = 1.0

      if response.status != 200:
        print(f"HTTP Error: {response.status}")
        response_text = response.data.decode('utf-8')
        print(f"Response body: {response_text}")
        return records, newest_time

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

      page_results = data.get('result', {}).get('logs', [])

      if not page_results:
        print(f"No more results (empty page)")
        break

      print(f"Page {page_num}: Retrieved {len(page_results)} events")
      records.extend(page_results)

      # Track newest event time
      for event in page_results:
        try:
          event_ts = event.get('time_generated') or event.get('receive_time')
          if event_ts:
            if isinstance(event_ts, (int, float)):
              event_dt = datetime.fromtimestamp(event_ts, tz=timezone.utc)
              event_time = event_dt.isoformat()
            else:
              event_time = str(event_ts)
            if newest_time is None or parse_datetime(event_time) > parse_datetime(newest_time):
              newest_time = event_time
        except Exception as e:
          print(f"Warning: Could not parse event time: {e}")

      # Check for more results
      scroll_token = data.get('result', {}).get('scrollToken')
      if not scroll_token:
        print("No more pages (no scroll token)")
        break

    except Exception as e:
      print(f"Error fetching logs: {e}")
      return records, newest_time

  print(f"Retrieved {len(records)} total records from {page_num} pages")
  return records, newest_time
    • requirements.txt:
    functions-framework==3.*
google-cloud-storage==2.*
urllib3>=2.0.0

  3. 點選「部署」即可儲存並部署函式。

  4. 等待部署作業完成 (2 到 3 分鐘)。

建立 Cloud Scheduler 工作

Cloud Scheduler 會定期將訊息發布至 Pub/Sub 主題，觸發 Cloud Run 函式。

  1. 前往 GCP 主控台的「Cloud Scheduler」。
  2. 點選「建立工作」。

  3. 請提供下列設定詳細資料：

    設定 值
    名稱 talon-logs-collector-hourly
    區域 選取與 Cloud Run 函式相同的區域
    頻率 0 * * * * (每小時整點)
    時區 選取時區 (建議使用世界標準時間)
    目標類型 Pub/Sub
    主題 選取主題 talon-logs-trigger
    郵件內文 {} (空白 JSON 物件)

  4. 點選「建立」。

排程頻率選項

根據記錄檔量和延遲時間要求選擇頻率：

頻率 Cron 運算式 用途
每 5 分鐘 */5 * * * * 高容量、低延遲
每 15 分鐘 */15 * * * * 中等音量
每小時 0 * * * * 標準 (建議)
每 6 小時 0 */6 * * * 少量、批次處理
每日 0 0 * * * 歷來資料集合

測試整合項目

  1. 在 Cloud Scheduler 控制台中找出您的工作。
  2. 按一下「強制執行」即可手動觸發工作。
  3. 稍等幾秒鐘。
  4. 前往「Cloud Run」>「Services」。
  5. 按一下 talon-logs-collector。
  6. 按一下 [Logs] (記錄) 分頁標籤。

  7. 確認函式是否順利執行。尋找：

    Fetching logs from YYYY-MM-DDTHH:MM:SS+00:00 to YYYY-MM-DDTHH:MM:SS+00:00
Page 1: Retrieved X events
Wrote X records to gs://talon-logs/talon/logs_YYYYMMDD_HHMMSS.ndjson
Successfully processed X records

  8. 依序前往「Cloud Storage」>「Buckets」。

  9. 按一下 bucket 名稱 (talon-logs)。

  10. 前往 talon/ 資料夾。

  11. 確認是否已建立含有目前時間戳記的新 .ndjson 檔案。

如果記錄中顯示錯誤：

  • HTTP 401：檢查環境變數中的 OAuth2 憑證
  • HTTP 403：確認服務帳戶在 Strata Cloud Manager 中是否具備必要權限
  • HTTP 429：頻率限制 - 函式會自動重試並延遲
  • 缺少環境變數：檢查是否已設定所有必要變數

在 Google SecOps 中設定動態饋給，擷取 Talon 記錄

  1. 依序前往「SIEM 設定」>「動態饋給」。
  2. 按一下「新增動態消息」。
  3. 按一下「設定單一動態饋給」。
  4. 在「動態饋給名稱」欄位中輸入動態饋給名稱 (例如 Talon Logs)。
  5. 選取「Google Cloud Storage V2」做為「來源類型」。
  6. 選取「Talon」做為「記錄類型」。

  7. 按一下「取得服務帳戶」。系統會顯示專屬服務帳戶電子郵件地址，例如：

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

  8. 複製這個電子郵件地址。

  9. 點選「下一步」。

  10. 指定下列輸入參數的值：

    • 儲存空間 bucket URL：輸入 GCS bucket URI，並加上前置路徑：

      gs://talon-logs/talon/
      • 取代：
        • talon-logs：您的 GCS bucket 名稱。
        • talon：儲存記錄的選用前置字元/資料夾路徑 (如為根目錄，請留空)。

    • 來源刪除選項：根據偏好設定選取刪除選項：

      • 永不：移轉後一律不刪除任何檔案 (建議用於測試)。
      • 刪除已轉移的檔案：成功轉移檔案後刪除檔案。

      • 刪除已轉移的檔案和空白目錄：成功轉移檔案後，刪除檔案和空白目錄。

    • 檔案存在時間上限：包含在過去天數內修改的檔案 (預設為 180 天)

    • 資產命名空間：資產命名空間

    • 擷取標籤：要套用至這個動態饋給事件的標籤

  11. 點選「下一步」。

  12. 在「Finalize」(完成) 畫面中檢查新的動態饋給設定，然後按一下「Submit」(提交)。

將 IAM 權限授予 Google SecOps 服務帳戶

  • Google SecOps 服務帳戶需要 GCS bucket 的「Storage 物件檢視者」角色。
  1. 依序前往「Cloud Storage」>「Buckets」。
  2. 按一下 bucket 名稱。
  3. 前往「權限」分頁標籤。
  4. 按一下「授予存取權」。
  5. 請提供下列設定詳細資料：
    • 新增主體：貼上 Google SecOps 服務帳戶電子郵件地址
    • 指派角色：選取「Storage 物件檢視者」
  6. 按一下 [儲存]。

UDM 對應表

記錄欄位 UDM 對應 邏輯
user.externalId、user.tenantExternalId、policy.action additional.fields 如果來源欄位不為空白，則會與每個來源欄位的標籤合併
時間戳記 metadata.event_timestamp 使用日期篩選器，以 ISO8601 和 yyyy-MM-ddTHH:mm:ss.SSSSSSSSSZ 格式剖析
has_principal、has_target metadata.event_type 如果 has_principal 為 true 且 has_target 為 false，則設為 STATUS_UPDATE，否則設為 GENERIC_EVENT
user.tenantId metadata.product_deployment_id 如果值不是空白，則直接複製該值
類型 metadata.product_event_type 如果值不是空白，則直接複製該值
device.deviceUuid metadata.product_log_id 如果值不是空白，則直接複製該值
network.protocol network.application_protocol 如果符合 (?i)https，則設為「HTTPS」
network.http.method network.http.method 如果值不是空白，則直接複製該值
device.userAgent network.http.parsed_user_agent 如果值不是空白，則直接複製該值
device.userAgent network.http.user_agent 如果值不是空白，則直接複製該值
user.tenantName observer.hostname 如果值不是空白，則直接複製該值
device.hostname principal.hostname 如果值不是空白，則直接複製該值
device.ipAddress principal.ip 使用 grok 模式 %{IP:prin_ip} 擷取的 IP，如果不是空白則合併
user.email principal.user.email_addresses 如果符合電子郵件規則運算式 ^.+@.+$，系統就會合併
user.name principal.user.user_display_name 如果值不是空白，則直接複製該值
user.id principal.user.userid 如果值不是空白，則直接複製該值
device.browserType、device.browserVersion、device.browserBrand、batchId security_result.about.resource.attribute.labels 如果來源欄位不為空白，則會與每個來源欄位的標籤合併
policy.ruleId security_result.rule_id 如果值不是空白，則直接複製該值
policy.ruleDescription security_result.summary 如果值不是空白，則直接複製該值
device.os.type、event_platform target.platform 如果 device.os.type == "windows"，則設為 WINDOWS；如果 event_platform 位於 ["Mac","iOS"] 中，則設為 MAC；如果 event_platform == "Lin"，則設為 LINUX
metadata.product_name 設為「Talon」
metadata.vendor_name 設為「TALON」

還有其他問題嗎？向社群成員和 Google SecOps 專業人員尋求答案。