📘 תיעוד 120

ניטור

למד כיצד להפעיל ולהגדיר את OpenTelemetry עבור Claude Code.

עקוב אחרי שימוש ב-Claude Code, עלויות ופעילות כלים בכל הארגון באמצעות ייצוא נתוני טלמטריה דרך OpenTelemetry (OTel). Claude Code מייצא מדדים כנתוני סדרות זמן דרך פרוטוקול המדדים הסטנדרטי, אירועים דרך פרוטוקול היומנים/אירועים, ובאופן אופציונלי עקבות מבוזרות דרך OpenTelemetry.

[!NOTE]

עבור Claude API או Managed Agents, ראה OpenTelemetry עבור Claude API.

#התחלה מהירה

הגדר את OpenTelemetry באמצעות משתני סביבה:

# 1. Enable telemetry
export CLAUDE_CODE_ENABLE_TELEMETRY=1

# 2. Choose exporters (both are optional - configure only what you need)
export OTEL_METRICS_EXPORTER=otlp       # Options: otlp, prometheus, console, none
export OTEL_LOGS_EXPORTER=otlp          # Options: otlp, console, none

# 3. Configure OTLP endpoint (for OTLP exporter)
export OTEL_EXPORTER_OTLP_PROTOCOL=grpc
export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317

# 4. Set authentication (if required)
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer your-token"

# 5. For debugging: reduce export intervals, and reset them for production use
export OTEL_METRIC_EXPORT_INTERVAL=10000  # 10 seconds (default: 60000ms)
export OTEL_LOGS_EXPORT_INTERVAL=5000     # 5 seconds (default: 5000ms)

# 6. Run Claude Code
claude

כדי לאמת הגדרה שמייצאת מדדים, בדוק ב-backend שלך את המדד claude_code.session.count, ש-Claude Code פולט כשסשן מתחיל. כדי לאמת הגדרה של יומנים בלבד, שלח פרומפט ובדוק את האירוע claude_code.user_prompt.

אם לא מגיע דבר, הפעל את Claude Code עם claude --debug-file <path> ובדוק את היומן שהוא כותב לנתיב הזה. Claude Code מדווח על כשלים מהמייצאים שאתה מגדיר כשגיאות [3P telemetry], כאשר 3P פירושו צד שלישי. שורות עם הקידומת [Anthropic telemetry] מתארות את הטלמטריה התפעולית הנפרדת של Anthropic ואינן מצביעות על בעיה בהגדרה שלך.

לאפשרויות הגדרה מלאות, ראה את מפרט OpenTelemetry.

#הגדרת מנהל

מנהלים יכולים להגדיר את הגדרות OpenTelemetry עבור כל המשתמשים דרך קובץ ההגדרות המנוהלות. ראה את קדימות ההגדרות למידע נוסף על האופן שבו הגדרות מוחלות.

דוגמה להגדרת הגדרות מנוהלות:

{
  "env": {
    "CLAUDE_CODE_ENABLE_TELEMETRY": "1",
    "OTEL_METRICS_EXPORTER": "otlp",
    "OTEL_LOGS_EXPORTER": "otlp",
    "OTEL_EXPORTER_OTLP_PROTOCOL": "grpc",
    "OTEL_EXPORTER_OTLP_ENDPOINT": "http://collector.example.com:4317",
    "OTEL_EXPORTER_OTLP_HEADERS": "Authorization=Bearer example-token"
  }
}

באפליקציית Claude Desktop, סשנים בלשונית Code קוראים את ההגדרות המנוהלות האלה מהמקורות שמגיעים לכל סוג של סשן Desktop. טופס ה-OpenTelemetry עבור Cowork תחת Monitoring בהגדרות Data and privacy של קונסולת הניהול חל על סשני Cowork בלבד, ולכן גם ה-CLI בטרמינל וגם לשונית Code לא מייצאים לאספן שהגדרת שם.

Claude Code מתעלם ממשתני מייצא OpenTelemetry בקובצי .claude/settings.json ו-.claude/settings.local.json של מאגר, ולכן מאגר לא יכול להשתמש בהם כדי להפעיל טלמטריה, לבחור לאן היא הולכת, או ללכוד תוכן. הגדר אותם בהגדרות מנוהלות, או שכל מפתח יגדיר אותם במעטפת שלו או ב-~/.claude/settings.json. מאגר עדיין יכול לכבות אות על ידי הגדרת בורר המייצא שלו, כגון OTEL_LOGS_EXPORTER, ל-none, אלא אם הגדרות מנוהלות, קובץ --settings, או הסביבה שממנה אתה מפעיל את Claude Code מגדירים את המשתנה הזה.

Claude Code לא מעביר משתני סביבה OTEL_* לתהליכי המשנה שהוא מפעיל, כולל כלי Bash, hooks, שרתי MCP ושרתי שפה. יישום שמכיל מכשור OpenTelemetry ושאתה מריץ דרך כלי Bash לא יורש את נקודת הקצה או את הכותרות של המייצא של Claude Code, ולכן הגדר את המשתנים האלה ישירות בפקודה אם היישום הזה צריך לייצא טלמטריה משלו.

#כיצד הגדרות מנוהלות נועלות את יעד ה-OTLP

כאשר אתה מגדיר משתנה OTEL_EXPORTER_OTLP_* בהגדרות מנוהלות, Claude Code מסיר בעת ההפעלה משתנים סותרים שהמפתח הגדיר ורושם אזהרה ביומן הדיבוג. מה שמוסר תלוי באיזה משתנה הגדרת:

• נקודות קצה: כאשר אתה מגדיר את OTEL_EXPORTER_OTLP_ENDPOINT, Claude Code מסיר כל נקודת קצה לפי אות שהמפתח הגדיר. מפתחים לא יכולים להפנות אות אחד לאספן אחר, ולכן אין צורך להגדיר גם את משתני נקודת הקצה לפי אות בהגדרות המנוהלות.

• פרוטוקולים: כאשר אתה מגדיר את OTEL_EXPORTER_OTLP_PROTOCOL, Claude Code מסיר כל פרוטוקול לפי אות שהמפתח הגדיר.

• אישורים: כאשר אתה מגדיר את OTEL_EXPORTER_OTLP_HEADERS, OTEL_EXPORTER_OTLP_CLIENT_KEY, או OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE, Claude Code מסיר את הגרסאות לפי אות של המשתנה הזה שהמפתח הגדיר, וגם כל משתנה נקודת קצה שהמפתח הגדיר, כללי או לפי אות, משום שאישורים אלה היו מגיעים אחרת לאספן שההגדרות המנוהלות לא בחרו.

• בוררי מייצא: OTEL_METRICS_EXPORTER, OTEL_LOGS_EXPORTER, ו-OTEL_TRACES_EXPORTER בבטא פועלים לפי קדימות רגילה לכל מפתח. הגדרה של מפתח עדיין יכולה להשבית אות או להעביר אותו למייצא הקונסולה, ולכן הגדר את הבוררים גם בהגדרות המנוהלות אם אתה צריך שהם יהיו נעולים. בין מקורות ניהול, OTEL_LOGS_EXPORTER פועל לפי יחידת הטלמטריה בעוד שני הבוררים האחרים מתמזגים לפי מפתח. נדרש Claude Code בגרסה v2.1.223 או חדשה יותר.

• נקודות קצה של מעקב בבטא: כאשר מעקב בטא מפורט פעיל, Claude Code מייצא יומנים ועקבות אל BETA_TRACING_ENDPOINT במקום דרך מייצאי היומנים והעקבות. לכן Claude Code מסיר BETA_TRACING_ENDPOINT שהמפתח הגדיר בכל פעם שאחת מההגדרות המנוהלות האלה קובעת את היעד של אחד האותות:

  • נקודת קצה או אישור כלליים, או של יומנים/עקבות
  • otelHeadersHelper
  • בורר מייצא של יומנים או עקבות שמוגדר ל-none, ל-console, או לריק, ערכים שמשאירים את האות מחוץ לאספן
  • CLAUDE_CODE_ENABLE_TELEMETRY כבוי

  נקודת קצה או אישור של מדדים בלבד לא מסירים אותו. לפני v2.1.251, BETA_TRACING_ENDPOINT שהמפתח הגדיר הפנה מחדש את היומנים והעקבות שמעקב הבטא המפורט מייצא גם כאשר הגדרות מנוהלות קבעו את האספן.

Claude Code לא מסיר משתנים לפי אות שאתה מגדיר בהגדרות המנוהלות עצמן, ולכן אפשר לנתב אות אחד לאספן אחר על ידי הגדרת המשתנה שלו שם, כפי שעושה דוגמת ה-SIEM. אם אתה מגדיר שם אישור לפי אות, Claude Code מסיר את נקודת הקצה שהמפתח הגדיר עבור האות הזה.

התנהגות ההסרה הזו משנה לאן הטלמטריה נמסרת, לא את מה ש-Claude Code אוסף.

לפני v2.1.217, כל משתנה פעל לפי קדימות הגדרות לכל מפתח בנפרד, ולכן נקודת קצה ספציפית לאות שהוגדרה בהגדרות המשתמש או במעטפת הפנתה את האות הזה הרחק מהאספן המנוהל.

כאשר אפליקציית הדסקטופ או runner של סביבה באירוח עצמי מפעילים את Claude Code ומציינים נקודת קצה של OTLP בסביבה שהם מספקים, Claude Code נועל את היעד באותו אופן: משתני הטלמטריה של המשגר מסירים משתנים שהמפתח הגדיר בדיוק כפי שעושות הגדרות מנוהלות. Claude Code לא מסיר משתנים שהמשגר עצמו הגדיר. נדרש Claude Code בגרסה v2.1.251 או חדשה יותר.

#פרטי הגדרה

#משתני הגדרה נפוצים

המשתנים האלה מגדירים מייצאים, נקודות קצה והתנהגות ייצוא עבור כל הפריסות.

אם אתה מגדיר משתנה נקודת קצה או פרוטוקול לפי אות, כגון OTEL_EXPORTER_OTLP_METRICS_ENDPOINT, Claude Code משתמש בו במקום במשתנה הכללי עבור האות הזה. אם אתה מגדיר משתנה כותרות לפי אות, כגון OTEL_EXPORTER_OTLP_METRICS_HEADERS, Claude Code ממזג אותו עם OTEL_EXPORTER_OTLP_HEADERS הכללי עבור האות הזה.

במכונות עם הגדרות מנוהלות, ראה כיצד הגדרות מנוהלות נועלות את יעד ה-OTLP לגבי מה ש-Claude Code מסיר.

עבור הפרוטוקולים http/protobuf ו-http/json, Claude Code שולח כל בקשת ייצוא עם כותרת Content-Length.

#אימות mTLS

האופן שבו אתה מגדיר אישורי לקוח עבור מייצא OTLP תלוי בפרוטוקול OTLP שבשימוש עבור האות הזה, שמוגדר דרך OTEL_EXPORTER_OTLP_PROTOCOL או דרך הדריסה לפי אות. אותה הגדרה חלה על מדדים, יומנים ועקבות.

עבור grpc, ה-SDK של OpenTelemetry קורא את משתני OTLP הסטנדרטיים ישירות, ולכן הגדרות קיימות שמגדירות את משתני המדדים לפי אות ממשיכות לעבוד. במכונות עם הגדרות מנוהלות, Claude Code עשוי להסיר בעת ההפעלה אישורים ונקודות קצה לפי אות שהמפתח הגדיר.

#בקרת קרדינליות של מדדים

משתני הסביבה הבאים שולטים באילו מאפיינים נכללים במדדים כדי לנהל קרדינליות:

קרדינליות נמוכה יותר משמעה בדרך כלל ביצועים טובים יותר ועלויות אחסון נמוכות יותר, אבל נתונים פחות מפורטים לניתוח.

#עקבות (בטא)

מעקב מבוזר מייצא spans שמקשרים כל הנחיית משתמש לבקשות ה-API ולהרצות הכלים שהיא מפעילה, כך שאפשר לראות בקשה מלאה כעקבה אחת במערכת המעקב.

המעקב כבוי כברירת מחדל. כדי להפעיל אותו, הגדירו גם את CLAUDE_CODE_ENABLE_TELEMETRY=1 וגם את CLAUDE_CODE_ENHANCED_TELEMETRY_BETA=1, ואז הגדירו את OTEL_TRACES_EXPORTER כדי לבחור לאן נשלחים ה-spans. העקבות משתמשות מחדש בהגדרות OTLP המשותפות עבור נקודת קצה, פרוטוקול, כותרות ו-mTLS. במחשבים עם הגדרות מנוהלות, Claude Code עשוי להסיר אישורים ונקודות קצה שהוגדרו לכל אות בנפרד על ידי מפתח בהפעלה.

ה-spans מסתירים כברירת מחדל את טקסט הנחיית המשתמש, פרטי קלט הכלים ותוכן הכלים. הגדירו OTEL_LOG_USER_PROMPTS=1, OTEL_LOG_TOOL_DETAILS=1 ו-OTEL_LOG_TOOL_CONTENT=1 כדי לכלול אותם.

כשהמעקב פעיל, תהליכי משנה של Bash ו-PowerShell יורשים אוטומטית משתנה סביבה TRACEPARENT שמכיל את הקשר העקבה של W3C של ה-span הפעיל של הרצת הכלי. זה מאפשר לכל תהליך משנה שקורא את TRACEPARENT להציב את ה-spans שלו כילדים תחת אותה עקבה, ומאפשר מעקב מבוזר מקצה לקצה דרך סקריפטים ופקודות ש-Claude מריץ.

כשהמעקב פעיל ו-Claude Code מחובר ישירות ל-API של Anthropic, כל בקשת מודל נושאת כותרת W3C traceparent שמוגדרת להקשר של ה-span claude_code.llm_request, וכותרת traceresponse של ה-API נרשמת כקישור span. יחד אלה מחברים את ה-spans בצד הלקוח של Claude Code לעקבה בצד השרת דרך כל מתווך תואם. בקשות HTTP MCP יוצאות נושאות traceparent באותו אופן. הכותרת לא נשלחת לספקים של צד שלישי.

כברירת מחדל, כותרת traceparent בבקשות מודל ובקשות HTTP MCP נשלחת רק כש-ANTHROPIC_BASE_URL לא מוגדר או מצביע על ה-API של Anthropic, כי חלק מהפרוקסי דוחים כותרות לא מוכרות. משתנה TRACEPARENT של תהליך המשנה נשלט על ידי אותו מתג לשם עקביות. אם מריצים את Claude Code דרך פרוקסי מותאם של ANTHROPIC_BASE_URL ורוצים שהקשר העקבה יופץ, הגדירו CLAUDE_CODE_PROPAGATE_TRACEPARENT=1.

ב-Agent SDK ובסשנים לא אינטראקטיביים שמתחילים עם -p, Claude Code גם קורא את TRACEPARENT ו-TRACESTATE מהסביבה שלו כשמתחיל כל span של אינטראקציה. זה מאפשר לתהליך מטמיע להעביר את הקשר העקבה הפעיל של W3C לתהליך המשנה, כך שה-spans של Claude Code מופיעים כילדים של העקבה המבוזרת של הקורא. סשנים אינטראקטיביים מתעלמים מ-TRACEPARENT נכנס כדי להימנע מירושה מקרית של ערכים סביבתיים מסביבות CI או קונטיינר.

הקשר העקבה הנכנס חל גם על אירועים. ב-Agent SDK ובסשנים של -p שבהם TRACEPARENT מוגדר, כל רשומת יומן אירוע OTLP נושאת ערכי trace_id ו-span_id שמחברים אותה לעקבה של האפליקציה, גם כשמייצא העקבות לא מוגדר, כך שמערכת הרישום יכולה לקשר אירועים לשאר העקבה.

רשומה שנפלטת בזמן שאינטראקציה פעילה נושאת את המזהים של ה-span של האינטראקציה, גם כש-Claude Code פולט אותה מחוץ להקשר האסינכרוני של ה-span, למשל בקריאת callback של בקשת הרשאה או עבור רשומה שנשמרה במאגר בזמן ההפעלה ויוצאה מאוחר יותר. רשומה שנפלטת בלי span אינטראקציה פעיל נושאת ישירות את מזהי TRACEPARENT הנכנסים.

#היררכיית span

כל הנחיית משתמש מתחילה span שורש claude_code.interaction. קריאות API, קריאות כלים והרצות hook נרשמות כילדים שלו. ל-spans של כלים יש שני spans ילדים משלהם: אחד לזמן ההמתנה להחלטת הרשאה ואחד להרצה עצמה. כשכלי Agent, או כלי Task הישן, מפעיל subagent, ה-spans של ה-API והכלים של ה-subagent מקוננים תחת ה-span claude_code.tool של ההורה.

claude_code.interaction
├── claude_code.llm_request
├── claude_code.hook                    (requires detailed beta tracing)
└── claude_code.tool
    ├── claude_code.tool.blocked_on_user
    ├── claude_code.tool.execution
    └── (Agent tool) subagent claude_code.llm_request / claude_code.tool spans

ב-Agent SDK ובסשנים של claude -p, claude_code.interaction עצמו הופך לילד של ה-span של הקורא כש-TRACEPARENT מוגדר בסביבה.

כש-hook מסוג PreToolUse דוחה קריאת כלי למועד מאוחר יותר, Claude Code שומר את הקשר העקבה של התור שדחה אותה. כשממשיכים את הסשן והכלי רץ שוב, ה-spans של הכלי מצטרפים לעקבה של אותו תור מוקדם יותר כילדים של ה-span claude_code.interaction של התור.

#מאפייני span

כל span נושא את המאפיינים הסטנדרטיים ועוד מאפיין span.type שתואם את שמו. הטבלאות למטה מפרטות את המאפיינים הנוספים שמוגדרים על כל span. ה-spans llm_request, tool.execution ו-hook מגדירים סטטוס OpenTelemetry ERROR כשהם רושמים כשל. שאר ה-spans תמיד מסתיימים בסטטוס UNSET.

claude_code.interaction

claude_code.llm_request

כל ניסיון חוזר נרשם גם כאירוע span בשם gen_ai.request.attempt עם המאפיינים attempt ו-client_request_id.

claude_code.tool

אירוע span tool.output על claude_code.tool

אם מגדירים OTEL_LOG_TOOL_CONTENT=1, קריאות Read ו-Bash יכולות לרשום אירוע span tool.output על ה-span claude_code.tool. קריאות Edit ו-Write רושמות אחד רק כשמגדירים גם OTEL_LOG_TOOL_DETAILS=1. המשתנה הזה לא מוגבל לשני הכלים האלה, אז בדקו את השורה שלו בטבלת התצורה עבור הארגומנטים שהוא מוסיף במקומות אחרים.

כלי MCP, WebFetch ו-WebSearch רושמים את האירוע הזה גם, ב-Claude Code גרסה v2.1.283 או חדשה יותר.

Claude Code כותב את האירוע הזה מהחזרה מוצלחת של קריאת כלי, כך שקריאה שמעלה שגיאה לא רושמת כלום, בכל כלי. מבין הקריאות שכן חוזרות, הוא לא רושם אירוע tool.output עבור:

• קריאה לכל כלי שאינו Read, Edit, Write, Bash, WebFetch, WebSearch וכלי MCP
• Read שמחזיר משהו שאינו טקסט קובץ, למשל תמונה, PDF, או קריאה חוזרת של קובץ שהתוכן שלו לא השתנה
• קריאת Edit או Write, אלא אם מגדירים גם OTEL_LOG_TOOL_DETAILS=1
• קריאת WebFetch או WebSearch ש-Claude Code העביר לרקע בזמן שהיא רצה כדי שהודעה ממתינה תוכל להגיע אל Claude. גם התוצאה שמגיעה אחר כך לא נרשמת. כדי ללמוד מתי Claude Code מעביר קריאה, ראו When Claude Code sends what you queued עבור הטרמינל ואת שדה priority עבור sessions של Agent SDK

האירוע נושא את המאפיינים האלה, כל אחד נחתך במגבלת התוכן (60 KB כברירת מחדל). Gated by מציין את המשתנה שמאפיין צריך בנוסף ל-OTEL_LOG_TOOL_CONTENT=1, ועבור Edit ו-Write המשתנה הזה שולט באירוע עצמו ולא במאפיין.

מאפיין tool_name של ה-span ההורה אומר מאיזה כלי האירוע הגיע. מאפיין שנחתך במגבלת התוכן מלווה ב-<attribute>_truncated וב-<attribute>_original_length.

claude_code.tool.blocked_on_user

החלטה cancelled עם source user_abort אומרת שהודעה שצריכה מסירה מיידית קטעה את התור בזמן שהנחיית ההרשאה או בדיקת מצב אוטומטי היו בהמתנה. למשל, במהלך בדיקת מצב אוטומטי, למשתמש הייתה הודעה בתור והוא שלח אותה מיד.

claude_code.tool.execution

claude_code.hook

ה-span הזה מופיע רק כש-tracing בטא מפורט פעיל, מה שדורש ENABLE_BETA_TRACING_DETAILED=1 ו-BETA_TRACING_ENDPOINT, זוג שגם משנה לאן הלוגים וה-traces שלכם הולכים. הגדירו את הזוג ב-shell, בהגדרות משתמש, או בהגדרות מנוהלות. שני המשתנים מתעלמים מהם ב-הגדרות פרויקט ומקומיות. CLAUDE_CODE_ENHANCED_TELEMETRY_BETA לבדו לא מייצר אותו.

ב-sessions אינטראקטיביים של CLI, tracing בטא מפורט דורש גם שהארגון שלכם יהיה ברשימת המורשים של הפיצ'ר. sessions של Agent SDK ו-sessions לא אינטראקטיביים עם -p לא דורשים רשימת מורשים.

[!WARNING]

הגדירו ENABLE_BETA_TRACING_DETAILED רק לניפוי שגיאות, לא בייצור. ל-tracing בטא מפורט יש נפח ייצוא גבוה, ומאפייני התוכן שלו אינם חלק מסכמת ה-span היציבה.

מאפייני תוכן תחת tracing בטא מפורט

[!NOTE]

מאפיינים נוספים שנושאים תוכן כמו new_context, system_reminders, system_prompt_preview, user_system_prompt, tool_input ו-response.model_output נפלטים רק כש-tracing בטא מפורט פעיל. הם אינם חלק מסכמת ה-span היציבה.

המאפיינים האלה מופיעים על ה-spans למטה, ו-Gated by מציין את המשתנה שמאפיין צריך בנוסף ל-tracing בטא מפורט. ערכים ארוכים ממגבלת התוכן (60 KB כברירת מחדל) נחתכים.

תחת tracing בטא מפורט עם OTEL_LOG_USER_PROMPTS=1, Claude Code פולט גם אירוע claude_code.system_prompt שנושא את פרומפט המערכת המלא, חתוך במגבלת התוכן. הוא מגיע בפעם הראשונה ש-session שולח כל פרומפט מערכת נבדל, ושוב אחרי compaction.

#כותרות דינמיות

עבור סביבות ארגוניות שדורשות אימות דינמי, אפשר להגדיר סקריפט שמייצר כותרות באופן דינמי. כותרות דינמיות חלות רק על הפרוטוקולים http/protobuf ו-http/json. עם הפרוטוקול grpc, Claude Code משתמש רק במשתני הכותרות הסטטיים, OTEL_EXPORTER_OTLP_HEADERS והווריאנטים שלו לפי אות.

#תצורת הגדרות

הוסיפו ל-.claude/settings.json, והחליפו את הנתיב בסקריפט שלכם:

{
  "otelHeadersHelper": "/path/to/generate-otel-headers.sh"
}

הערך יכול להיות הנתיב לקובץ בר הרצה, כולל נתיב שמכיל רווחים, או שורת פקודת shell עם ארגומנטים. ב-Windows, הערך תמיד רץ דרך ה-shell, אז צטטו נתיב שמכיל רווחים בתוך ערך ה-JSON.

#דרישות הסקריפט

הסקריפט חייב להפיק JSON תקין עם זוגות מפתח-ערך מסוג מחרוזת שמייצגים כותרות HTTP:

#!/bin/bash
# Example: Multiple headers
echo "{\"Authorization\": \"Bearer $(get-token.sh)\", \"X-API-Key\": \"$(get-api-key.sh)\"}"

אם ה-helper נכשל או מדפיס פלט שלא עומד בדרישות האלה, הייצוא נכשל ושרת הטלמטריה שלכם לא מקבל כלום מה-session עד שה-helper עובד שוב. Claude Code מדווח על הכשל ב:

• התראת אזהרה ב-sessions אינטראקטיביים, otelHeadersHelper failed; telemetry is not being exported, שמוצגת פעם אחת לכל session כשה-helper נכשל לראשונה
• פלט /status
• לוג הניפוי, כשרצים עם --debug או אחרי הרצת /debug ב-session
• stderr, ב-sessions לא אינטראקטיביים שהתחילו עם -p

#התנהגות רענון

סקריפט ה-helper של הכותרות רץ בהפעלה ולאחר מכן מעת לעת כדי לתמוך ברענון טוקן. כברירת מחדל, הסקריפט רץ כל 29 דקות. התאימו את המרווח עם משתנה הסביבה CLAUDE_CODE_OTEL_HEADERS_HELPER_DEBOUNCE_MS.

#תמיכה בארגון עם כמה צוותים

ארגונים עם כמה צוותים או מחלקות יכולים להוסיף מאפיינים מותאמים אישית כדי להבחין בין קבוצות שונות באמצעות משתנה הסביבה OTEL_RESOURCE_ATTRIBUTES:

# Add custom attributes for team identification
export OTEL_RESOURCE_ATTRIBUTES="department=engineering,team.id=platform,cost_center=eng-123"

המאפיינים המותאמים האלה נכללים בכל המדדים ובכל האירועים, ומאפשרים לכם:

• לסנן מדדים לפי צוות או מחלקה
• לעקוב אחרי עלויות לפי מרכז עלות
• ליצור לוחות מחוונים ייעודיים לצוות
• להגדיר התראות לצוותים מסוימים

Claude Code מצרף את הערכים האלה כמאפיינים על כל נקודת נתונים של מדד ועל כל רשומת אירוע, בנוסף לשליחתם בבלוק המשאב של OTLP. מכיוון שרוב מערכות היעד של מדדים חושפות מאפיינים של נקודות נתונים כתוויות שאפשר לתשאל, אפשר לקבץ ולסנן מדדים לפי המפתחות המותאמים שלכם ישירות. למעט מאפייני המאגר vcs.* במאפייני מאגר, מפתחות מותאמים לעולם לא דורסים את המאפיינים הסטנדרטיים כגון user.id או session.id: כשמפתח מתנגש, Claude Code שומר את הערך המובנה.

כל מפתח מותאם הופך לתווית על כל סדרת מדדים, ולכן ערכים בעלי קרדינליות גבוהה מעלים את עלות האחסון במערכת היעד של המדדים. כדי לשלוח מאפיינים מותאמים רק בבלוק המשאב ולהשמיט אותם מתוויות של נקודות הנתונים, הגדירו OTEL_METRICS_INCLUDE_RESOURCE_ATTRIBUTES=false. ראו בקרת קרדינליות של מדדים.

[!WARNING]

משתנה הסביבה OTEL_RESOURCE_ATTRIBUTES משתמש בזוגות key=value מופרדים בפסיקים, עם דרישות פורמט מחמירות:

• אסור רווחים: ערכים לא יכולים להכיל רווחים. לדוגמה, user.organizationName=My Company לא תקין
• פורמט: חייב להיות זוגות key=value מופרדים בפסיקים: key1=value1,key2=value2
• תווים מותרים: רק תווי US-ASCII, למעט תווי בקרה, רווח לבן, גרשיים כפולים, פסיקים, נקודה-פסיק ולוכסנים הפוכים
• תווים מיוחדים: תווים מחוץ לטווח המותר חייבים בקידוד אחוזים

לערך שהיה צריך רווח, השתמשו בקווים תחתונים או ב-camelCase. הדוגמאות הבאות מגדירות את org.name בכל אחת מהצורות:

העתק

export OTEL_RESOURCE_ATTRIBUTES="org.name=Johns_Organization"
export OTEL_RESOURCE_ATTRIBUTES="org.name=JohnsOrganization"

אפשר לקודד באחוזים כל תו, לא רק את התווים שהוחרגו. הדוגמה הזו מקודדת גם את הרווח וגם את הגרש:

העתק

export OTEL_RESOURCE_ATTRIBUTES="org.name=John%27s%20Organization"

עטיפת ערכים בגרשיים לא מבריחה רווחים. לדוגמה, org.name="My Company" נותן את הערך המילולי "My Company" כשהגרשיים כלולים, ולא את My Company.

#שיוך טלמטריה לסשנים של Desktop SSH

כדי לראות על איזו מכונה מרוחקת רץ סשן Desktop SSH, תנו שם לכל מכונה במאפיין מותאם. מדדים ואירועים לא מציינים את שם המכונה שעליה רץ הסשן.

בכל מכונה מרוחקת, הוסיפו את OTEL_RESOURCE_ATTRIBUTES לבלוק env שמפעיל את הטלמטריה, בקובץ ההגדרות המנוהל שהסשן קורא. כתבו את השם במפורש בקובץ של כל מכונה. Claude Code לא מרחיב את הערך, ולכן host.name=$(hostname) מגיע כתווים האלה.

הדוגמה הבאה נותנת למכונה את השם build-7:

{
  "env": {
    "CLAUDE_CODE_ENABLE_TELEMETRY": "1",
    "OTEL_METRICS_EXPORTER": "otlp",
    "OTEL_LOGS_EXPORTER": "otlp",
    "OTEL_EXPORTER_OTLP_PROTOCOL": "grpc",
    "OTEL_EXPORTER_OTLP_ENDPOINT": "http://collector.example.com:4317",
    "OTEL_RESOURCE_ATTRIBUTES": "host.name=build-7"
  }
}

כששום דבר אחר לא מגדיר את המשתנה, host.name מגיע בבלוק המשאב, בסשני Desktop SSH וב-CLI במכונה הזו. למקומות נוספים שבהם מופיעים מאפיינים מותאמים, ראו תמיכה בארגון עם כמה צוותים.

אם השם לא מגיע, בדקו את אחת הסיבות האלה:

• הגדרתם אותו במחשב שמריץ את Desktop: Desktop לא מעביר לסשן ה-SSH ערך שהגדרתם שם
• ייצאתם אותו ב-/etc/profile או בקובץ אחר שרק מעטפות login קוראות: השם מגיע כשמריצים את claude מ-login shell, אבל לא בסשן Desktop SSH. Desktop לא מפעיל את Claude Code דרך login shell. הגדירו את המשתנה תחת env בקובץ ההגדרות המנוהל במכונה המרוחקת.
• יש רווח בתוך הערך: Claude Code לא מעתיק אז אף אחד מהמפתחות אל אירועים או אל נקודות נתונים, ולא מדווח על שגיאה. הוציאו את הרווח מהערך.
• משהו אחר כבר מגדיר את המשתנה: בסשן שאפליקציית שולחן העבודה מפעילה, משתנה שכבר מוגדר בסביבת ההפעלה גובר על קובצי הגדרות. יומן הדיבוג מציין כל משתנה שהתעלמו ממנו. כשפריסת Desktop של צד שלישי מציינת נקודת קצה של OTLP בסביבה שהיא מספקת, הסביבה הזו נושאת את OTEL_RESOURCE_ATTRIBUTES של Desktop עצמה.

#תצורות לדוגמה

הגדירו את משתני הסביבה האלה לפני הרצת claude. כל תרחיש למטה מציג תצורה מלאה, וכל משתנה מתואר תחת משתני תצורה נפוצים. כדי לאשר שתצורה נכנסה לתוקף, בדקו במערכת היעד את המדד claude_code.session.count אחרי התחלת סשן. התחלה מהירה מכסה אימות של יומנים בלבד ומה לבדוק כששום דבר לא מגיע.

לניפוי שגיאות במסוף עם מרווח ייצוא של שנייה אחת:

export CLAUDE_CODE_ENABLE_TELEMETRY=1
export OTEL_METRICS_EXPORTER=console
export OTEL_METRIC_EXPORT_INTERVAL=1000

עבור OTLP על גבי gRPC:

export CLAUDE_CODE_ENABLE_TELEMETRY=1
export OTEL_METRICS_EXPORTER=otlp
export OTEL_EXPORTER_OTLP_PROTOCOL=grpc
export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317

עבור Prometheus, בגרידה מ-http://localhost:9464/metrics:

export CLAUDE_CODE_ENABLE_TELEMETRY=1
export OTEL_METRICS_EXPORTER=prometheus

בסביבה באירוח עצמי, הסשן קושר את פורט 9464 רק בקיבולת ברירת המחדל של הרץ, שהיא אחד. בקיבולת גבוהה יותר, הרץ חושף מחדש מונים ומדידים של הסשן בנקודת הקצה /metrics שלו.

כדי לשלוח מדדים לכמה מייצאים:

export CLAUDE_CODE_ENABLE_TELEMETRY=1
export OTEL_METRICS_EXPORTER=console,otlp
export OTEL_EXPORTER_OTLP_PROTOCOL=http/json

כדי לשלוח מדדים ויומנים לנקודות קצה או למערכות יעד שונות:

export CLAUDE_CODE_ENABLE_TELEMETRY=1
export OTEL_METRICS_EXPORTER=otlp
export OTEL_LOGS_EXPORTER=otlp
export OTEL_EXPORTER_OTLP_METRICS_PROTOCOL=http/protobuf
export OTEL_EXPORTER_OTLP_METRICS_ENDPOINT=http://metrics.example.com:4318
export OTEL_EXPORTER_OTLP_LOGS_PROTOCOL=grpc
export OTEL_EXPORTER_OTLP_LOGS_ENDPOINT=http://logs.example.com:4317

כדי לייצא מדדים בלבד, בלי אירועים או יומנים:

export CLAUDE_CODE_ENABLE_TELEMETRY=1
export OTEL_METRICS_EXPORTER=otlp
export OTEL_EXPORTER_OTLP_PROTOCOL=grpc
export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317

כדי לייצא אירועים ויומנים בלבד, בלי מדדים:

export CLAUDE_CODE_ENABLE_TELEMETRY=1
export OTEL_LOGS_EXPORTER=otlp
export OTEL_EXPORTER_OTLP_PROTOCOL=grpc
export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317

#טלמטריה מסשני ענן ומ-Claude Tag

סשני ענן, כולל סשני ערוץ של Claude Tag, רצים בסביבות ענן ולא על המכשירים של המשתמשים, ולכן קובץ הגדרות מנוהל או פרופיל מעטפת במכשירים האלה לא מגדיר את הטלמטריה שלהם. לסשנים בסביבות שמתארחות ב-Anthropic, הסעיף הזה מכסה איפה להגדיר את משתני הטלמטריה, איך להנגיש את האספן מהסביבה, ואיך להבדיל בין סשני ענן לסשני Claude Tag בנתונים המיוצאים.

כדי לייצא טלמטריה מהסשנים האלה, הגדירו את CLAUDE_CODE_ENABLE_TELEMETRY ואת משתני OTEL_*, עם אותם מפתחות כמו בדוגמה של תצורת מנהל, באחד משני מקומות:

• הגדרות שמנוהלות בשרת: הוסיפו אותן לבלוק env של ההגדרות שמנוהלות בשרת של הארגון. Claude Code שולף את ההגדרות האלה בהפעלה בכל מקום שבו חלות הגדרות שמנוהלות בשרת, כולל המכונות של המשתמשים וסשני ענן שאינם סשני ערוץ של Claude Tag. סשני Claude Tag לא מקבלים את ההגדרות שמנוהלות בשרת שלכם, ולכן המסלול הזה לא מגדיר אותם.
• משתני הסביבה: הוסיפו אותם למשתני הסביבה של סביבת ענן כדי להגדיר רק את הסשנים שרצים בסביבה הזו. זה המסלול שמגיע לסשני Claude Tag.

כל מי שמשתמש בסביבה יכול לקרוא את המשתנים שלה, ולכן אל תשימו שם פרטי אימות, כגון אסימון אספן ב-OTEL_EXPORTER_OTLP_HEADERS. גם סוד רשת בסביבה לא עוזר, כי ייצוא הטלמטריה של Claude Code עצמו הוא אחת מהבקשות שלעולם לא מקבלות את הסוד. אם האספן דורש פרטי אימות, הגדירו את כל הייצוא דרך הגדרות שמנוהלות בשרת, כי כשמגדירים שם פרטי אימות, Claude Code מסיר משתני נקודת קצה שהוגדרו מחוץ להגדרות מנוהלות.

קחו בחשבון את האילוצים האלה כשמגדירים טלמטריה לסשני ענן:

• תנו לסשנים להגיע לאספן: Claude Code שולח את הייצוא דרך הרשת של הסשן, ולכן אם הוא מגיע למארח ב-OTEL_EXPORTER_OTLP_ENDPOINT תלוי ברמת הגישה לרשת של הסביבה. אם סשנים לא יכולים להגיע לדומיין של האספן ברמה שבחרתם, הוסיפו את הדומיין לרשימת ההיתרים של הסביבה, כי אין הגדרה שמנוהלת בשרת שמוסיפה דומיינים לרשימת ההיתרים של הרשת של סביבה.
• ערוצי Claude Tag: בצעו את שינויי רשימת ההיתרים וכל שינוי במשתני הסביבה בסביבה המשותפת שמוגדרת כברירת המחדל של הארגון או שמוצמדת לערוץ.
• Cowork מוגדר בנפרד: סשני Cowork לא מקבלים הגדרות שמנוהלות בשרת, כפי שטבלת כיסוי המשטחים מראה, ולכן בלוק env שמנוהל בשרת לא מגדיר את הטלמטריה שלהם.

#שיוך טלמטריה לסשני ענן

כברירת מחדל, מדדים ואירועים מסשן ענן נושאים את המאפיינים הסטנדרטיים, כולל session.id, ccr.session.id ו-organization.id, כך שאפשר לסנן לפי סשן או לפי ארגון בלי תצורה נוספת. הערך של ccr.session.id הוא CLAUDE_CODE_REMOTE_SESSION_ID של הסשן. כדי להפוך אותו לכתובת התמליל של הסשן, ראו קישור הפלט בחזרה לסשן.

כדי להבדיל בין סשני ענן, קבצו או סננו לפי ccr.session.id, לא לפי session.id.

כדי לשייך טלמטריה ביתר פירוט, השתמשו באפשרויות האלה:

• זיהוי סשני Claude Tag: הגדירו OTEL_METRICS_INCLUDE_ENTRYPOINT=true, כפי שמתואר תחת בקרת קרדינליות של מדדים. המדדים נושאים אז את app.entrypoint, והערך שלו הוא claude-in-slack בסשני Claude Tag.
• הוספת מאפיינים מותאמים: הגדירו את OTEL_RESOURCE_ATTRIBUTES באותו מקום שבו הגדרתם את שאר משתני OTEL_* לסשנים האלה. אם תבצעו לו export בסקריפט ההקמה של הסביבה, הערך לא מגיע אל Claude Code: סקריפט ההקמה הוא סקריפט Bash נפרד שרץ לפני ש-Claude Code מופעל, ומשתנים שהוא מייצא מסתיימים יחד איתו.

בסשני ערוץ של Claude Tag, Claude עובד כזהות המשותפת של הארגון ולא כחבר כלשהו, ולכן אל תסתמכו על מאפייני user.* כדי לזהות מי תייג את Claude.

#מדדים ואירועים זמינים

#מאפיינים סטנדרטיים

כל המדדים והאירועים חולקים את המאפיינים הסטנדרטיים האלה:

בסשנים שמחוברים לשער יישומי Claude דרך /login, ה-CLI חותם את הייצואים בזהות המאומתת: user.id הוא ה-subject של ה-IdP, user.email הוא האימייל המחובר, ו-user.groups נושא את חברות הקבוצות ב-IdP כמחרוזת מופרדת בפסיקים. כל ייצוא נושא גם identity.source: gateway-oidc. זהות השער מוחלת אחרונה, ולכן מפתחות user.* ו-identity.* שהוגדרו דרך OTEL_RESOURCE_ATTRIBUTES מתעלמים מהם בסשנים האלה.

[!NOTE]

אירועים ש-Claude Code רושם לפני שמפתח מתחבר לא נושאים את זהות השער. כאשר Claude Code פותח סשן שמנותק מהשער, למשל אחרי שהשער מסיים את ההתחברות, אירועי ההפעלה שנרשמים לפני ההתחברות נושאים את user.id האנונימי וללא identity.source. אלה כוללים את managed_settings_resolved, plugin_loaded, ו-mcp_server_connection.

למאפייני הזהות בסשנים של Claude Desktop ו-Cowork שמתחברים דרך שער, ראה את ההפניה telemetry של השער.

אירועים כוללים בנוסף את המאפיינים הבאים. אלה לעולם לא מצורפים למדדים כי הם היו גורמים לקרדינליות לא חסומה:

• prompt.id: UUID שמקשר הנחיה של משתמש לכל האירועים הבאים עד ההנחיה הבאה. ראה מאפייני מתאם אירועים.
• workspace.host_paths: ספריות workspace של המארח שנבחרו ביישום שולחן העבודה, כמערך מחרוזות
• workflow.run_id: מזהה ריצה, עם הקידומת wf_, על אירועי ה-API והכלים שנפלטים על ידי סוכנים ששייכים לריצת כלי Workflow. סינון אירועים לפי workflow.run_id אחד משחזר את בקשות ה-API ואת תוצאות הכלים של הריצה הזו. המזהה מכסה את הסוכנים שסקריפט ה-workflow מפעיל וכל סוכן שהם מפעילים בתורם, למשל הפעלות skill. הוא תואם למזהה הריצה שמדווח בתוצאת כלי ה-Workflow.
• workflow.name: שם ה-workflow, ה-meta.name של הסקריפט שלו, נפלט לצד workflow.run_id. שמות workflow מובנים מופיעים כלשונם כאשר הריצה מפעילה את הסקריפט המובנה ללא שינוי. שמות שחיבר משתמש, כולל עותקים ערוכים של סקריפטים מובנים, מוחלפים ב-custom אלא אם OTEL_LOG_TOOL_DETAILS=1 מוגדר.
• agent_id: מזהה ה-subagent שהעלה את האירוע, למשל a3f2c1b4d5e6f7a80. אירועים שנושאים אותו כוללים אירועי API וכלים של subagent, את אירועי assistant_response שלו, ו-subagent_completed עבור ה-subagent שהסתיים. נעדר באירועי הסשן הראשי ובאירועי עמית בתהליך. ה-span agent_id של ה-subagent הוא אותו ערך, או מוסיף תווית אחרי ה-a המוביל כמו ב-acompact-3f2c1b4d5e6f7a80. דורש Claude Code v2.1.310 או חדש יותר
• parent_agent_id: ה-agent_id של הסוכן שהפעיל או חידש לאחרונה את ה-subagent שהעלה את האירוע. נעדר כאשר הסוכן הזה הוא הסשן הראשי. דורש Claude Code v2.1.310 או חדש יותר

#מאפייני מאגר

הגדר OTEL_METRICS_INCLUDE_REPOSITORY=true כדי לתייג מדדים ואירועים בזהות המאגר של הסשן, כך שאספן משותף יוכל לייחס שימוש לפי מאגר. דורש Claude Code v2.1.269 או חדש יותר.

Claude Code גוזר את המאפיינים האלה פעם אחת לכל סשן מה-remote של origin של המאגר. כאשר ה-remote של HTTPS ושל SSH של מאגר מציינים את אותו מארח ואת אותו נתיב, כפי שהם עושים ב-GitHub, ב-GitLab וב-Bitbucket Cloud, שניהם מייצרים ערכים זהים:

הערכים באותיות קטנות, ופרטי התחברות, מחרוזות שאילתה ו-fragments מכתובת ה-remote של ה-remote לעולם לא מופיעים בהם. המאפיינים מושמטים כאשר לסשן אין remote של origin, כאשר ה-remote אינו בצורת URL, או כאשר המאגר העוטף היחיד הוא ספריית הבית שלך.

כדי לקבל את המאפיינים האלה מסשן ענן, הגדר את משתני הטלמטריה, כולל OTEL_METRICS_INCLUDE_REPOSITORY, בסביבת הענן שלו. אפשר גם את הדומיין של האספן שלך בגישת הרשת של הסביבה.

מפתח vcs.* שאתה מצהיר עליו ב-OTEL_RESOURCE_ATTRIBUTES מחליף את הערך הנגזר עבור המפתח הזה. אם אתה מצהיר על vcs.repository.url.full, Claude Code לעולם לא קורא את ה-remote ומדווח רק על המפתחות שעליהם הצהרת.

אם שיבוטי HTTPS ו-SSH של מאגר אחד מדווחים על ערכים שונים, למשל בהתקנה באירוח עצמי שכתובת השיבוט שלה ב-HTTPS נושאת קידומת נתיב שחסרה בכתובת ה-SSH, הצהר על vcs.repository.url.full ב-OTEL_RESOURCE_ATTRIBUTES יחד עם כל מפתח vcs.* אחר שאתה רוצה שידווח. כל שיבוט מדווח אז על הזהות שעליה הצהרת.

המאפיינים זורמים רק אל המייצאים שלך. הטלמטריה של Anthropic משמיטה כל מפתח vcs.*.

#מדדים

Claude Code מייצא את המדדים הבאים. עמודת היחידה מציגה את מחרוזת יחידת OpenTelemetry המצורפת לכל מדד. מדדי ספירה לא נושאים יחידה.

כאשר prometheus הוא המייצא היחיד שרשום ב-OTEL_METRICS_EXPORTER, Claude Code משמיט את היחידות USD, tokens ו-s מהמדדים המיוצאים כדי שה-scrape יישאר בפורמט טקסט Prometheus תקין. שמות המדדים לא משתנים, ותצורות שמשלבות מייצאים, למשל otlp,prometheus, שומרות את היחידות.

#פרטי מדדים

כל מדד כולל את המאפיינים הסטנדרטיים שרשומים למעלה. מדדים עם מאפיינים נוספים שתלויים בהקשר מצוינים למטה.

#מונה סשנים

מוגדל בתחילת כל סשן.

מאפיינים:

• כל המאפיינים הסטנדרטיים
• start_type: איך הסשן הופעל. אחד מ-"fresh", "resume", "continue", או "agents_view". הערך "agents_view" מזהה את תהליך לוח הבקרה claude agents, ממשק מקומי שהמשתמש הפעיל ולא סשן שיחה. סנן לפי הערך הזה כדי להפריד הפעלות תהליך ממשק מסשני שיחה בלוחות הבקרה שלך.

#מונה שורות קוד

מוגדל כאשר קוד נוסף או מוסר.

מאפיינים:

• כל המאפיינים הסטנדרטיים
• type: ("added", "removed")
• model: מזהה המודל של המודל שביצע את השינוי (למשל, "claude-sonnet-5")

#מונה בקשות משיכה

מוגדל כאשר Claude Code יוצר בקשת משיכה או בקשת מיזוג דרך פקודת shell או כלי MCP.

מאפיינים:

• כל המאפיינים הסטנדרטיים

#מונה קומיטים

מוגדל בעת יצירת קומיטים של git דרך Claude Code.

מאפיינים:

• כל המאפיינים הסטנדרטיים

#מונה עלות

מוגדל אחרי כל בקשת API.

המאפיינים agent.name, skill.name, plugin.name, mcp_server.name ו-mcp_tool.name כל אחד מסתיר חלק מהשמות למציין מקום "custom" או "third-party" כברירת מחדל. אם תגדיר OTEL_LOG_TOOL_DETAILS=1, הם נושאים את השמות האמיתיים במקום. לפני v2.1.273, מוני העלות והטוקנים ואירועי api_request, api_error ו-api_refusal נשאו את הערכים המוסתרים גם כאשר OTEL_LOG_TOOL_DETAILS=1 הוגדר.

מאפיינים:

• כל המאפיינים הסטנדרטיים
• model: מזהה מודל (למשל, "claude-sonnet-5")
• query_source: קטגוריית תת המערכת שהנפיקה את הבקשה. אחד מ-"main", "subagent", או "auxiliary"
• speed: "fast" כאשר הבקשה השתמשה במצב מהיר. נעדר אחרת
• effort: רמת מאמץ שהוחלה על הבקשה: "low", "medium", "high", "xhigh", או "max". נעדר כאשר Claude Code לא שולח רמת מאמץ, למשל במודל שלא תומך במאמץ.
• agent.name: סוג ה-subagent שהנפיק את הבקשה. שמות סוכנים מובנים וסוכנים מתוספי marketplace רשמי מופיעים כלשונם. שמות סוכנים אחרים שהגדיר משתמש מוחלפים ב-"custom". נעדר כאשר הבקשה לא הונפקה על ידי סוג subagent בעל שם.
• skill.name: skill פעיל עבור הבקשה, שמוגדר על ידי כלי ה-Skill או פקודת /, או שעובר בירושה ל-subagent שהופעל. שמות skill מובנים, ארוזים, שהגדיר משתמש, ומתוסף marketplace רשמי מופיעים כלשונם. שמות skill מתוסף צד שלישי מוחלפים ב-"third-party". נעדר כאשר אין skill פעיל.
• plugin.name: התוסף הבעלים כאשר ה-skill הפעיל או ה-subagent מסופק על ידי תוסף. שמות תוספי marketplace רשמי מופיעים כלשונם. שמות תוספי צד שלישי מוחלפים ב-"third-party". נעדר כאשר לא ל-skill ולא ל-subagent יש תוסף בעלים.
• marketplace.name: ה-marketplace שממנו הותקן התוסף הבעלים. נפלט רק עבור תוספי marketplace רשמי, גם כאשר OTEL_LOG_TOOL_DETAILS=1 מוגדר. נעדר אחרת.
• mcp_server.name: שרת MCP שתוצאת הכלי שלו נצרכה בבקשה הזו. שמות שרתים מובנים, שמועברים דרך claude.ai, ומרשם רשמי מופיעים כלשונם. שמות שרתים שהוגדרו על ידי משתמש מוחלפים ב-"custom". נעדר כאשר הבקשה לא צרכה תוצאת כלי MCP. לפני v2.1.222, Claude Code הגדיר את המאפיין הזה על כל בקשה אחרי קריאת כלי MCP, לא רק על בקשות שצרכו תוצאת כלי, ולכן לוחות בקרה שמצרפים אותו מציגים ירידה אחרי השדרוג.
• mcp_tool.name: כלי MCP שתוצאתו נצרכה בבקשה הזו, עם אותה הסתרה ואותה התנהגות גרסה כמו mcp_server.name. נעדר כאשר הבקשה לא צרכה תוצאת כלי MCP.

#מונה טוקנים

מוגדל אחרי כל בקשת API.

מאפיינים:

• כל המאפיינים הסטנדרטיים
• type: ("input", "output", "cacheRead", "cacheCreation"). הסוג "input" לא כולל טוקנים שנקראו מהמטמון של ההנחיה או נכתבו אליו, והם נספרים תחת "cacheRead" ו-"cacheCreation". הסוג "cacheCreation" סופר כתיבות מטמון עם משך חיי המטמון של חמש דקות ושל שעה אחת יחד.
• model: מזהה מודל (למשל, "claude-sonnet-5")
• query_source: קטגוריית תת המערכת שהנפיקה את הבקשה. אחד מ-"main", "subagent", או "auxiliary"
• speed: "fast" כאשר הבקשה השתמשה במצב מהיר. נעדר אחרת
• effort: רמת מאמץ שהוחלה על הבקשה. ראה מונה עלות לפרטים.
• agent.name, skill.name, plugin.name, marketplace.name, mcp_server.name, mcp_tool.name: ייחוס skill, תוסף, סוכן ו-MCP עבור הבקשה. ראה מונה עלות להגדרות ולהתנהגות ההסתרה.

#מונה החלטות כלי עריכת קוד

מוגדל כאשר המשתמש מקבל או דוחה שימוש בכלי Edit, Write, או NotebookEdit.

מאפיינים:

• כל המאפיינים הסטנדרטיים
• tool_name: שם הכלי ("Edit", "Write", "NotebookEdit")
• decision: החלטת המשתמש ("accept", "reject")
• source: מאיפה הגיעה ההחלטה. אחד מ-"config", "hook", "user_permanent", "user_temporary", "user_abort", או "user_reject". ראה את אירוע החלטת כלי למשמעות של כל ערך.
• language: שפת התכנות של הקובץ שנערך, למשל "TypeScript", "Python", "JavaScript", או "Markdown". מחזיר "unknown" עבור סיומות קובץ שלא מזוהות.

#מונה זמן פעיל

עוקב אחרי הזמן בפועל שהושקע בשימוש פעיל ב-Claude Code, בלי זמן סרק. המדד הזה מוגדל במהלך אינטראקציות משתמש, למשל הקלדה וקריאת תשובות, ובמהלך עיבוד CLI, למשל הרצת כלים ויצירת תשובת AI.

מאפיינים:

• כל המאפיינים הסטנדרטיים
• type: "user" לאינטראקציות מקלדת, "cli" להרצת כלים ולתשובות AI

#אירועים

Claude Code מייצא את האירועים הבאים דרך לוגים/אירועים של OpenTelemetry (כאשר OTEL_LOGS_EXPORTER מוגדר):

#מאפייני מתאם אירועים

כשמשתמש שולח פרומפט, Claude Code עשוי לבצע כמה קריאות API ולהריץ כמה כלים. המאפיין prompt.id מאפשר לקשור את כל האירועים האלה בחזרה לפרומפט היחיד שהפעיל אותם.

כדי לעקוב אחרי כל הפעילות שהפעיל פרומפט יחיד, סננו את האירועים לפי ערך prompt.id מסוים. זה מחזיר את אירוע user_prompt, כל אירועי api_request, וכל אירועי tool_result שהתרחשו בזמן עיבוד הפרומפט הזה.

event.sequence מתחיל ב-0 בכל פעם שתהליך Claude Code מתחיל, וסופר כלפי מעלה לאורך חיי התהליך. הוא ממשיך לספור מעבר ל-/clear, שמקצה session.id חדש. אם ממשיכים סשן בלי fork, הסשן שומר את session.id שלו אבל לוקח את ערכי event.sequence מהתהליך שחידש אותו, כך שבתוך סשן אחד אירוע מאוחר יכול לשאת ערך נמוך יותר מאירוע מוקדם, או לחזור על ערך. כדי לסדר את אירועי הסשן, מיינו לפי event.timestamp והשתמשו ב-event.sequence כדי לסדר אירועים שחולקים חותמת זמן.

לשחזור ברמת הודעה, כל מחלקת אירוע נושאת מפתח שתואם לשדה בתמליל הסשן. פורמט רשומת התמליל הוא פנימי ל-Claude Code ומשתנה בין גרסאות, כך שצינור שמבצע join על השדות האלה יכול להישבר בכל שחרור. התייחסו ל-joins כספציפיים לגרסה ולא כחוזה יציב:

• message.uuid ב-user_prompt, assistant_response ו-api_response_body
• request_id באירועי ה-API, נשמר כ-requestId ברשומות ה-assistant של התמליל
• tool_use_id באירועי tool_result ו-tool_decision, ובאירועי safety_event מלבד אלה של סוף תור

#אירוע פרומפט משתמש

נרשם כשפרומפט נשלח, כולל בתורות ש-Claude Code מתחיל בעצמו.

שם האירוע: claude_code.user_prompt

מאפיינים:

• כל המאפיינים הסטנדרטיים
• event.name: "user_prompt"
• event.timestamp: חותמת זמן ISO 8601
• event.sequence: מונה לכל תהליך לסידור אירועים, מתואר תחת מאפייני מתאם אירועים
• prompt_length: אורך הפרומפט
• prompt: תוכן הפרומפט. מוסתר כברירת מחדל. הגדירו OTEL_LOG_USER_PROMPTS=1 כדי לכלול אותו
• prompt_text: אותו ערך כמו prompt, מוסתר תחת אותו שער. בקאנד ששומר שמות מאפיינים עם נקודה כאובייקטים מקוננים קורא את prompt.id כ-id בתוך אובייקט בשם prompt ועלול לאבד את מחרוזת הפרומפט. קראו שם את prompt_text במקום. דורש Claude Code v2.1.287 או חדש יותר
• message.uuid: UUID של הודעת המשתמש שנוצרה, תואם לרשומת התמליל שנשמרה. נעדר בשיגורי פקודות, שיכולים לייצר אפס הודעות או הודעות רבות.
• command_name: שם הפקודה כשהפרומפט מפעיל אחת. שמות פקודות מובנות וארוזות כמו compact או debug נפלטים כפי שהם. כינויים כמו reset נפלטים כפי שהוקלדו ולא כשם הקנוני. שמות פקודות מותאמות, של תוסף ושל MCP מתכווצים ל-custom או mcp אלא אם OTEL_LOG_TOOL_DETAILS=1 מוגדר
• command_source: מקור הפקודה כשהוא קיים: builtin, custom או mcp. פקודות שמספק תוסף מדווחות כ-custom

#אירוע תגובת assistant

נרשם אחרי כל בקשת API שמחזירה תוכן טקסט מהמודל. רק בלוקי הטקסט של התגובה נכללים. בלוקי thinking ובלוקי tool-use לא נכללים.

שם האירוע: claude_code.assistant_response

מאפיינים:

• כל המאפיינים הסטנדרטיים
• event.name: "assistant_response"
• event.timestamp: חותמת זמן ISO 8601
• event.sequence: מונה לכל תהליך לסידור אירועים, מתואר תחת מאפייני מתאם אירועים
• response_length: אורך טקסט התגובה בתווים
• response: טקסט התגובה, נחתך במגבלת התוכן (60 KB כברירת מחדל). מוסתר ל-<REDACTED> כברירת מחדל. הגדירו OTEL_LOG_ASSISTANT_RESPONSES=1 כדי לכלול אותו. כש-OTEL_LOG_ASSISTANT_RESPONSES לא מוגדר, OTEL_LOG_USER_PROMPTS שולט בו במקום, לכן הגדירו OTEL_LOG_ASSISTANT_RESPONSES=0 כדי להשאיר תגובות מוסתרות בזמן שרישום פרומפטים פעיל
• model: מזהה המודל (לדוגמה, "claude-sonnet-5")
• request_id: מזהה בקשת API, מתואר תחת מאפייני מתאם אירועים
• message.uuid: UUID של רשומת התמליל הסופית של התגובה. תגובת API נשמרת כרשומת תמליל אחת לכל בלוק תוכן. זו האחרונה, שממנה שרשרת ה-parentUuid של התור הבא ממשיכה.
• query_source: תת-המערכת שהנפיקה את הבקשה, כמו "repl_main_thread", "compact", או שם subagent

#אירוע תוצאת כלי

נרשם כשכלי מסיים ביצוע. לא נפלט אם קריאת הכלי נדחתה. ראו את אירוע החלטת כלי לדחיות.

שם האירוע: claude_code.tool_result

מאפיינים:

• כל המאפיינים הסטנדרטיים
• event.name: "tool_result"
• event.timestamp: חותמת זמן ISO 8601
• event.sequence: מונה לכל תהליך לסידור אירועים, מתואר תחת מאפייני מתאם אירועים
• tool_name: שם הכלי
• tool_use_id: מזהה ייחודי להפעלת הכלי הזו. תואם ל-tool_use_id שמועבר ל-hooks, ומאפשר מתאם בין אירועי OTel לנתונים שנלכדו ב-hook.
• request_id: ה-request_id של תגובת ה-API שהכילה את קריאת הכלי הזו, כך שאפשר לחבר את הקריאה לאירועי ה-API של אותה תגובה. נעדר כשלתגובה הזו לא היה מזהה בקשה, או כשאף תגובת API לא הכילה את הקריאה. דורש Claude Code v2.1.310 או חדש יותר
• success: "true" או "false"
• duration_ms: זמן ביצוע במילישניות
• error_type: מחרוזת קטגוריית שגיאה כשהכלי נכשל, כמו "Error:ENOENT" או "ShellError"
• error (כש-OTEL_LOG_TOOL_DETAILS=1): הודעת השגיאה המלאה כשהכלי נכשל
• decision_type: תמיד "accept", כי האירוע הזה נפלט רק אחרי שהכלי רץ. קריאות שנדחו לא מייצרות תוצאת כלי
• decision_source: מאיפה הגיעה החלטת ההרשאה. אחד מ-"config", "hook", "user_permanent" או "user_temporary". ראו את אירוע החלטת כלי למשמעות כל ערך. מקורות הדחייה בלבד "user_abort" ו-"user_reject" אף פעם לא מופיעים באירוע הזה.
• tool_input_size_bytes: גודל קלט הכלי שעבר סריאליזציה ל-JSON, בבתים
• tool_result_size_bytes: גודל תוצאת הכלי בבתים
• mcp_server_scope: מזהה היקף שרת MCP (לכלי MCP)
• vcs.ref.head.revision, vcs.ref.head.name, vcs.ref.head.type (כש-OTEL_LOG_TOOL_DETAILS=1): זהות ה-commit של הרצת git commit מוצלחת על ידי כלי Bash או PowerShell. vcs.ref.head.revision הוא ה-SHA של ה-commit, vcs.ref.head.name הוא הענף שעליו בוצע ה-commit, ו-vcs.ref.head.type הוא branch. השם והסוג מושמטים כשה-commit בוצע על detached HEAD. דורש Claude Code v2.1.269 או חדש יותר
• tool_parameters (כש-OTEL_LOG_TOOL_DETAILS=1): מחרוזת JSON שמכילה פרמטרים ספציפיים לכלי. עבור השרתים המובנים של Claude Desktop, בסשנים ש-Claude Desktop מחזיק, הזוג mcp_server_name/mcp_tool_name נכלל גם כשהדגל כבוי, אותו חריג שמקורו ב-host כמו ב-אירוע החלטת כלי. הפרמטרים משתנים לפי הכלי:
  • עבור כלי Bash: כולל bash_command, full_command, timeout, description ו-dangerouslyDisableSandbox, ועוד git_commit_id ו-git_branch כשפקודת git commit מצליחה. git_commit_id הוא ה-SHA המלא של ה-commit כשה-commit הוא ה-HEAD של ספריית העבודה של הסשן, ו-SHA מקוצר של git אחרת. git_branch הוא הענף שעליו בוצע ה-commit, ומוסתר ב-detached HEAD
  • עבור כלי Bash של סביבת העבודה באפליקציית הדסקטופ, שמדווח גם tool_name כ-Bash: כולל רק bash_command, full_command ו-timeout
  • עבור כלי MCP: כולל mcp_server_name, mcp_tool_name
  • עבור כלי Skill: כולל skill_name
  • עבור כלי Agent או כלי Task הישן: כולל subagent_type
• tool_input (כש-OTEL_LOG_TOOL_DETAILS=1): ארגומנטי הכלי בסריאליזציית JSON. ערכים בודדים מעל 512 תווים נחתכים, והמטען המלא מוגבל לכ-~4 K תווים. חל על כל הכלים, כולל כלי MCP.

#אירוע בקשת API

נרשם לכל בקשת API אל Claude.

שם האירוע: claude_code.api_request

מאפיינים:

• כל המאפיינים הסטנדרטיים
• event.name: "api_request"
• event.timestamp: חותמת זמן ISO 8601
• event.sequence: מונה לכל תהליך לסידור אירועים, מתואר תחת מאפייני מתאם אירועים
• model: המודל שבשימוש (לדוגמה, "claude-sonnet-5")
• cost_usd: עלות משוערת ב-USD
• cost_usd_micros: עלות משוערת במיליוניות של דולר אמריקאי, נפלטת כמספר שלם
• duration_ms: משך הבקשה במילישניות
• input_tokens: מספר טוקני קלט, לא כולל טוקנים שנקראו מ-cache הפרומפט או נכתבו אליו
• output_tokens: מספר טוקני פלט
• cache_read_tokens: מספר טוקנים שנקראו מ-cache
• cache_creation_tokens: מספר טוקנים ששימשו ליצירת cache
• cache_creation_5m_tokens, cache_creation_1h_tokens: מספר הטוקנים שתגובת ה-API מדווחת שנכתבו ל-cache עם משך חיי cache של חמש דקות, ומספר הטוקנים שנכתבו עם משך חיים של שעה. שניהם 0 כשתגובת ה-API לא מדווחת אותם, גם כש-cache_creation_tokens גדול מאפס. דורש Claude Code v2.1.300 או חדש יותר
• request_id: מזהה בקשת API, כמו "req_011...", מתואר תחת מאפייני מתאם אירועים.
• client_request_id: UUID שנוצר בצד הלקוח ונשלח ככותרת הבקשה x-client-request-id. ראו את טבלת מאפייני מתאם האירועים למתי הוא מופיע
• speed: "fast" או "normal", מציין אם מצב מהיר היה פעיל
• query_source: תת-המערכת שהנפיקה את הבקשה, כמו "repl_main_thread", "compact", או שם subagent
• effort: רמת מאמץ שהוחלה על הבקשה: "low", "medium", "high", "xhigh" או "max". נעדר כש-Claude Code לא שולח רמת מאמץ, למשל במודל שלא תומך ב-effort.
• agent.name, skill.name, plugin.name, marketplace.name, mcp_server.name, mcp_tool.name: ייחוס skill, plugin, agent ו-MCP לבקשה. ראו מונה עלות להגדרות ולהתנהגות הסתרה.

#אירוע שגיאת API

נרשם כשבקשת API אל Claude נכשלת.

שם האירוע: claude_code.api_error

מאפיינים:

• כל המאפיינים הסטנדרטיים
• event.name: "api_error"
• event.timestamp: חותמת זמן ISO 8601
• event.sequence: מונה לכל תהליך לסידור אירועים, מתואר תחת מאפייני מתאם אירועים
• model: המודל שבשימוש (לדוגמה, "claude-sonnet-5")
• error: הודעת שגיאה
• status_code: קוד סטטוס HTTP כמספר. נעדר לשגיאות שאינן HTTP, כמו כשלי חיבור.
• duration_ms: משך הבקשה במילישניות
• attempt: מספר הניסיונות שבוצעו, כולל הבקשה הראשונית. זיהוי מיצוי ניסיונות חוזרים מציין מתי הספירה מתחילה מחדש
• request_id: מזהה בקשת API, כמו "req_011...", מתואר תחת מאפייני מתאם אירועים.
• client_request_id: UUID שנוצר בצד הלקוח ונשלח ככותרת הבקשה x-client-request-id. זמין גם כשכשל כמו timeout או שגיאת חיבור מעולם לא ייצר request_id של שרת. ראו את טבלת מאפייני מתאם האירועים למתי הוא מופיע.
• speed: "fast" או "normal", מציין אם מצב מהיר היה פעיל
• query_source: תת-המערכת שהנפיקה את הבקשה, כמו "repl_main_thread", "compact", או שם subagent
• effort: רמת מאמץ שהוחלה על הבקשה. נעדר כש-Claude Code לא שולח רמת מאמץ, למשל במודל שלא תומך ב-effort.
• agent.name, skill.name, plugin.name, marketplace.name, mcp_server.name, mcp_tool.name: ייחוס skill, plugin, agent ו-MCP לבקשה. ראו מונה עלות להגדרות ולהתנהגות הסתרה.

#אירוע סירוב API

נרשם כשבקשת API מחזירה stop_reason: "refusal". סירובים מגיעים בזרם תגובה מוצלח ולא כשגיאת HTTP, לכן אירוע api_error לא נורה עבורם. האירוע הזה מאפשר לעקוב אחרי תדירות סירובים ולקבץ סירובים לפי אותם מאפיינים כמו api_request ו-api_error.

שם האירוע: claude_code.api_refusal

מאפיינים:

• כל המאפיינים הסטנדרטיים
• event.name: "api_refusal"
• event.timestamp: חותמת זמן ISO 8601
• event.sequence: מונה לכל תהליך לסידור אירועים, מתואר תחת מאפייני מתאם אירועים
• model: מזהה המודל מהבקשה
• request_id: מזהה בקשת API, כמו "req_011...", מתואר תחת מאפייני מתאם אירועים.
• query_source: תת-המערכת שהנפיקה את הבקשה, כמו "repl_main_thread", "compact", או שם subagent. ראו api_request להגדרות.
• speed: "fast" כש-מצב מהיר פעיל, או "normal"
• attempt: מספר ניסיון חוזר. הניסיון הראשון הוא 1.
• effort: רמת מאמץ שהוחלה על הבקשה. נעדר כש-Claude Code לא שולח רמת מאמץ, למשל במודל שלא תומך ב-effort.
• server_fallback_hop: true כשה-fallback למודל בצד השרת של ה-API כבר ביצע ניסיון חוזר לסירוב הזה על מודל אחר, כך שהמשתמש לא ראה את הסירוב המסוים הזה. false כשהבקשה הסתיימה בסירוב. תור יחיד יכול לפלוט גם אירוע hop עם true וגם אירוע סופי מאוחר יותר עם false כשגם מודל ה-fallback מסרב.
• has_category: true כשתגובת ה-API נשאה stop_details.category של "cyber", "bio", "frontier_llm" או "reasoning_extraction". false כשהתגובה לא נשאה קטגוריה, או נשאה ערך מחוץ לקבוצה הזו. נעדר כש-server_fallback_hop הוא true, כי בלוקי hop לא נושאים stop_details.
• has_explanation: true כשתגובת ה-API נשאה stop_details.explanation, אחרת false. נעדר כש-server_fallback_hop הוא true.
• category: ערך stop_details.category מתגובת ה-API. אחד מ-"cyber", "bio", "frontier_llm" או "reasoning_extraction". מופיע רק כש-OTEL_LOG_TOOL_DETAILS=1 מוגדר ו-has_category הוא true.
• agent.name, skill.name, plugin.name, marketplace.name, mcp_server.name, mcp_tool.name: ייחוס skill, plugin, agent ו-MCP לבקשה. ראו מונה עלות להגדרות ולהתנהגות הסתרה.

#אירוע גוף בקשת API

נרשם עבור כל ניסיון בקשת API כאשר OTEL_LOG_RAW_API_BODIES מוגדר. נפלט אירוע אחד לכל ניסיון, כך שניסיונות חוזרים עם פרמטרים מותאמים מייצרים כל אחד אירוע משלו.

שם האירוע: claude_code.api_request_body

מאפיינים:

• כל המאפיינים הסטנדרטיים
• event.name: "api_request_body"
• event.timestamp: חותמת זמן ISO 8601
• event.sequence: מונה לכל תהליך לסידור האירועים, מתואר תחת מאפייני מתאם אירועים
• body: פרמטרי בקשת Messages API שסודרו כ-JSON, כגון הנחיית המערכת, ההודעות והכלים, חתוכים במגבלת התוכן (60 KB כברירת מחדל). תוכן extended-thinking בתורות עוזר קודמות מושחר. נפלט רק במצב inline (OTEL_LOG_RAW_API_BODIES=1).
• body_ref: נתיב מוחלט לקובץ <dir>/<uuid>.request.json שמכיל את הגוף ללא חיתוך. נפלט רק במצב קובץ (OTEL_LOG_RAW_API_BODIES=file:<dir>).
• body_length: אורך הגוף ללא חיתוך. בתים בקידוד UTF-8 כאשר OTEL_LOG_RAW_API_BODIES=file:<dir>, או יחידות קוד UTF-16 כאשר =1
• body_truncated: "true" כאשר התרחש חיתוך במצב inline. נעדר במצב קובץ וכאשר לא התרחש חיתוך.
• model: מזהה המודל מפרמטרי הבקשה
• query_source: תת המערכת שהנפיקה את הבקשה (לדוגמה, "compact")
• request_body_id: UUID שמזהה את גוף הבקשה של ניסיון זה. אירוע api_response_body של הניסיון שמצליח נושא את אותו ערך, כך שאפשר לזווג תגובה עם הבקשה המדויקת שיצרה אותה. דורש Claude Code v2.1.274 ואילך

#אירוע גוף תגובת API

נרשם עבור כל תגובת API מוצלחת כאשר OTEL_LOG_RAW_API_BODIES מוגדר.

במצב קובץ (OTEL_LOG_RAW_API_BODIES=file:<dir>), Claude Code גם מצרף שורת JSON אחת אל <dir>/index.jsonl עבור כל תגובה מוצלחת, עם השדות timestamp, session_id, query_source, model, request_id, message_id, message_uuid, request_file ו-response_file. קראו אותו כדי למצוא את קבצי הבקשה והתגובה שמאחורי הודעת תמליל נתונה בלי לשאול את מערכת הטלמטריה. קובץ האינדקס דורש Claude Code v2.1.274 ואילך.

שם האירוע: claude_code.api_response_body

מאפיינים:

• כל המאפיינים הסטנדרטיים
• event.name: "api_response_body"
• event.timestamp: חותמת זמן ISO 8601
• event.sequence: מונה לכל תהליך לסידור האירועים, מתואר תחת מאפייני מתאם אירועים
• body: תגובת Messages API שסודרה כ-JSON, כולל ה-id, בלוקי התוכן, השימוש וסיבת העצירה, חתוכה במגבלת התוכן (60 KB כברירת מחדל). תוכן extended-thinking מושחר. נפלט רק במצב inline (OTEL_LOG_RAW_API_BODIES=1).
• body_ref: נתיב מוחלט לקובץ <dir>/<request_id>.response.json שמכיל את הגוף ללא חיתוך. נפלט רק במצב קובץ (OTEL_LOG_RAW_API_BODIES=file:<dir>).
• body_length: אורך הגוף ללא חיתוך. בתים בקידוד UTF-8 כאשר OTEL_LOG_RAW_API_BODIES=file:<dir>, או יחידות קוד UTF-16 כאשר =1
• body_truncated: "true" כאשר התרחש חיתוך במצב inline. נעדר במצב קובץ וכאשר לא התרחש חיתוך.
• model: מזהה המודל
• query_source: תת המערכת שהנפיקה את הבקשה
• request_id: מזהה בקשת API, כגון "req_011...", מתואר תחת מאפייני מתאם אירועים.
• request_body_id: ה-request_body_id של אירוע api_request_body שהתגובה הזו עונה לו. דורש Claude Code v2.1.274 ואילך
• message.id: מזהה ההודעה שה-API הקצה לתגובה, שדה ה-id של גוף התגובה. דורש Claude Code v2.1.274 ואילך
• message.uuid: UUID של רשומת התמליל הסופית של התגובה. יחד עם request_body_id, הוא מקשר הודעת תמליל לגופי הבקשה והתגובה שמאחוריה. דורש Claude Code v2.1.274 ואילך

#אירוע החלטת כלי

נרשם כאשר מתקבלת החלטת הרשאה לכלי (accept/reject).

שם האירוע: claude_code.tool_decision

מאפיינים:

• כל המאפיינים הסטנדרטיים

• event.name: "tool_decision"

• event.timestamp: חותמת זמן ISO 8601

• event.sequence: מונה לכל תהליך לסידור האירועים, מתואר תחת מאפייני מתאם אירועים

• tool_name: שם הכלי (לדוגמה, "Read", "Edit", "Write", "NotebookEdit")

• tool_use_id: מזהה ייחודי להפעלה זו של הכלי. תואם ל-tool_use_id שמועבר ל-hooks, ומאפשר מתאם בין אירועי OTel לנתונים שנלכדו ב-hook.

• request_id: ה-request_id של תגובת ה-API שהכילה את קריאת הכלי הזו, כך שאפשר לחבר את הקריאה לאירועי ה-API של אותה תגובה. נעדר כאשר לתגובה הזו לא היה מזהה בקשה, או כאשר אף תגובת API לא הכילה את הקריאה. דורש Claude Code v2.1.310 ואילך

• decision: או "accept" או "reject"

• tool_source: תמיד נוכח. מקור הכלי, כקבוצה סגורה של ערכים שה-CLI כתב:

  • "builtin": הכלים של ה-CLI עצמו
  • "mcp": שרתי MCP באופן כללי
  • "sdk_host_builtin_mcp": שרת בתוך התהליך, מובנה בתוך Claude Desktop עצמו, בסשן ש-Claude Desktop הוא הבעלים שלו. Claude Desktop הוא הבעלים של סשן שהוא התחיל מאחת מנקודות הכניסה שלו, claude-desktop, claude-desktop-3p או local-agent, כאשר הסשן הזה אינו ילד מקונן. סשנים מקוננים, כולל סשנים ש-Claude Code עצמו מפעיל, מדווחים על השרתים האלה כ-"mcp"

• source: מהיכן הגיעה ההחלטה:

  • "config": הוחלט אוטומטית בלי הנחיה, על ידי אחד מהמקורות האלה:

    • הגדרות הפרויקט
    • כללי allow או deny בהגדרות האישיות של המשתמש
    • מדיניות מנוהלת ארגונית
    • דגלי --allowedTools או --disallowedTools
    • מצב ההרשאה הפעיל
    • מסווג מצב auto, שאת פסק הדין שלו אותו אירוע רושם ב-classifier_verdict
    • הענקה לשאר הסשן, שניתנה בהנחיית הרשאה מוקדמת יותר באותו סשן CLI אינטראקטיבי
    • הכלי בטוח מטבעו

    ערך source אינו מציין איזה מהמקורות האלה התאים. כדי למצוא איזה מהם סירב לקריאה, חפשו את אירוע הבטיחות עם אותו tool_use_id וקראו את מאפייני category ו-rule_source שלו. לחלק מהקריאות שסורבו אין אירוע בטיחות.

    Claude Code גם מדווח "config" כאשר בקשת הנחיית ההרשאה עצמה נכשלת. לדוגמה, הבקשה הזו נכשלת כאשר ה-callback canUseTool של Agent SDK או הכלי --permission-prompt-tool מחזיר תוצאה לא תקינה, או כאשר זרם הקלט נסגר בזמן שהבקשה ממתינה.

  • "hook": hook מסוג PreToolUse או PermissionRequest החזיר את ההחלטה.

  • "user_permanent": נפלט כאשר המשתמש בחר "Yes, and don't ask again for ..." בהנחיית הרשאה, וזה שומר כלל allow בהגדרות האישיות. ב-CLI האינטראקטיבי זה נפלט רק עבור הבחירה עצמה. קריאות מאוחרות יותר שתואמות את הכלל שנשמר פולטות "config" במקום זאת. ב-Agent SDK או בסשני -p לא אינטראקטיביים, גם הבחירה הראשונית וגם התאמות כללים מאוחרות פולטות "user_permanent". מטופל כ-accept.

  • "user_temporary": נפלט כאשר המשתמש בחר "Yes" בהנחיית הרשאה לאישור חד פעמי, או בחר אפשרות שמעניקה גישה לשאר הסשן בהנחיה לעריכת קובץ או לקריאה. ב-CLI האינטראקטיבי זה נפלט רק עבור הבחירה עצמה. קריאות מאוחרות יותר שההענקה בהיקף הסשן מתירה פולטות "config" במקום זאת. ב-Agent SDK או בסשני -p לא אינטראקטיביים, גם הבחירה וגם התאמות מאוחרות פולטות "user_temporary". מטופל כ-accept.

  • "user_abort": נפלט כאשר המשתמש סגר את הנחיית ההרשאה בלי לענות. ב-Agent SDK ובסשני -p לא אינטראקטיביים, זה כולל קטיעת התור בזמן שבקשת הרשאה של canUseTool או --permission-prompt-tool ממתינה. מטופל כ-reject.

  • "user_reject": נפלט כאשר המשתמש בחר "No" כשהוצגה הנחיה. ב-CLI האינטראקטיבי זה נפלט רק עבור הבחירה עצמה. קריאות שתואמות כלל deny בהגדרות האישיות של המשתמש פולטות "config" במקום זאת. ב-Agent SDK או בסשני -p לא אינטראקטיביים, קריאות שתואמות כלל deny בהגדרות האישיות פולטות "user_reject". מטופל כ-reject.

• classifier_verdict: פסק הדין של המסווג של מצב auto עבור הקריאה, או מדוע Claude Code דחה את הקריאה כאשר לא הגיע פסק דין. דורש Claude Code v2.1.301 ואילך

  • "allow": המסווג אישר את הקריאה
  • "block": המסווג חסם את הקריאה. בדיקת מסווג שנכשלת באמצע הדרך יכולה גם להסתיים כ-"block", כך שהשבתה חלקית של המסווג יכולה להופיע כיותר חסימות ולא כ-"unavailable"
  • "no_verdict": הבדיקה רצה אבל נתנה פסק דין לא שמיש, ולכן Claude Code דחה את הקריאה. הדחייה אינה אומרת שהמסווג מצא שהקריאה לא בטוחה
  • "unavailable": הבקשה למסווג נכשלה, לדוגמה במגבלת קצב, ב-timeout או בשגיאת חיבור, ולכן Claude Code דחה את הקריאה. עם סקירת מסווג בצד השרת, זה גם מסמן קריאה שנדחתה כי השרת לא החזיר פסק דין בטיחות

  המאפיין מופיע גם בקריאות של מצב plan כאשר המסווג סוקר פקודות במצב plan. המאפיין נעדר במקרים האלה:

  • כלל הרשאה של allow או deny החליט את הקריאה
  • Claude Code אישר את הקריאה במצב auto בלי לשאול את המסווג
  • המשתמש ענה להנחיה ש-Claude Code הציג אחרי חסימות חוזרות
  • בהרצה של -p בלי --permission-prompt-tool, Claude Code דחה את הקריאה אחרי חסימות חוזרות כי לא היה מי שיענה להנחיה. האירוע הזה מדווח decision כ-"reject" ו-source כ-"config"

• classifier_category (כאשר OTEL_LOG_TOOL_DETAILS=1): השם של הכלל המובנה שהמסווג ציין כאשר חסם את הקריאה, באותיות קטנות עם קווים תחתונים, כגון "data_exfiltration" עבור כלל Data Exfiltration. דורש Claude Code v2.1.301 ואילך. המאפיין נוכח כאשר שני אלה מתקיימים:

  • classifier_verdict הוא "block"
  • המסווג ציין בדיוק כלל אחד, והכלל הזה הוא כלל מובנה ולא כלל שכתבתם

  לפני v2.1.302, המאפיין גם נעדר בכל חסימה שסקירת מסווג בצד השרת החליטה.

• permission_mode: מצב הרשאה שהיה פעיל כאשר בדיקת ההרשאה של הקריאה הזו החלה: "default", "plan", "acceptEdits", "bypassPermissions", "dontAsk" או "auto". מצב ידני מופיע כ-"default". קריאת סוכן משנה מדווחת את מצב ההרשאה של סוכן המשנה ולא את זה של הסשן. דורש Claude Code v2.1.301 ואילך

• tool_parameters (כאשר OTEL_LOG_TOOL_DETAILS=1): מחרוזת JSON שמכילה פרמטרים ספציפיים לכלי. אותה צורה כמו אירוע תוצאת כלי, בלי שדות שלאחר הביצוע כגון git_commit_id. הערכים עשויים להיות שונים מ-tool_result עבור קריאה שהתקבלה, אם החלטת ההרשאה משכתבת את קלט הכלי באמצעות updatedInput. השתמשו במאפיין הזה כדי לראות איזו פקודה נדחתה כאשר decision הוא "reject".

  • עבור כלים "sdk_host_builtin_mcp": mcp_server_name ו-mcp_tool_name כלולים גם כאשר OTEL_LOG_TOOL_DETAILS כבוי, כי יישום המארח מגדיר את השמות האלה. בלעדיהם, קריאה שנדחתה לאחד מהשרתים המובנים האלה לא תהיה ניתנת לשיוך בזרם ברירת המחדל. עבור שרתי MCP שהוגדרו על ידי המשתמש, tool_name של האירוע הוא תמיד המחרוזת המילולית "mcp_tool", ושמות השרת והכלי מופיעים רק ב-tool_parameters כאשר הדגל דולק. תוכן הארגומנטים דורש את הדגל בכל מקום.
  • עבור כלי Bash: כולל bash_command, full_command, timeout, description, dangerouslyDisableSandbox. כלי ה-bash של סביבת העבודה באפליקציית שולחן העבודה גם מדווח tool_name כ-Bash, אבל כולל רק bash_command, full_command ו-timeout
  • עבור כלי MCP: כולל mcp_server_name, mcp_tool_name
  • עבור כלי Skill: כולל skill_name
  • עבור כלי Agent או כלי Task הישן: כולל subagent_type

אם מנמיכים את OTEL_LOGRECORD_ATTRIBUTE_COUNT_LIMIT של ה-SDK של OpenTelemetry אל מתחת למספר המאפיינים באירוע tool_decision, ה-SDK משמיט את המאפיינים ש-Claude Code הגדיר אחרונים. ה-SDK משמיט את אלה לפני כל מאפיין אחר, בסדר הזה, ומדלג על כל מאפיין שהאירוע אינו נושא:

1. parent_agent_id
2. agent_id
3. request_id
4. permission_mode
5. classifier_category
6. classifier_verdict

permission_mode, classifier_category ו-classifier_verdict נשמטים בסדר הזה ב-Claude Code v2.1.302 ואילך. parent_agent_id, agent_id ו-request_id דורשים v2.1.310 ואילך.

#אירוע בטיחות

נרשם כאשר בדיקה מסרבת לקריאת כלי או דורשת בקשת הרשאה, למעט קריאות בלי אירוע בטיחות. נרשם גם כאשר פרוקסי הרשת של ארגז החול מסרב לחיבור או לבקשה, וכאשר hook חוסם תוצאה. דורש Claude Code v2.1.307 או גרסה מאוחרת יותר.

האירוע מיוצא יחד עם שאר האירועים ואין לו הגדרה נפרדת. המאפיינים של האירוע עצמו אינם מכילים טקסט פקודה, נתיבי קבצים, שמות מארחים, או שמות של שרתי MCP וכלים. הרשומה נושאת גם את המאפיינים הסטנדרטיים שיש לכל אירוע, שיכולים לכלול את workspace.host_paths ואת מאפייני המאגר. כדי לראות את הפקודה או את כלי ה-MCP שמאחורי אירוע, הגדר OTEL_LOG_TOOL_DETAILS=1 וקרא את tool_parameters באירוע tool_decision התואם.

שם האירוע: claude_code.safety_event

מאפיינים:

• כל המאפיינים הסטנדרטיים
• event.name: "safety_event"
• event.timestamp: חותמת זמן ISO 8601
• event.sequence: מונה לכל תהליך לסידור אירועים, מתואר תחת מאפייני מתאם אירועים
• category: הבדיקה או התוצאה, ערך קטגוריה
• decision: "accept", "reject", או "sent_back" כאשר hook חסם תוצאה או סיום תור
• decision_source: מי או מה החליט, ערך source של tool_decision או "other"
• reason_code: הסיבה של הבדיקה, כגון "rule:policySettings", "mode:dontAsk", "hook:PreToolUse", "classifier:auto-mode", "bashMiss:too-complex", או "unknown"
• reason_type: סוג הסיבה של הבדיקה, כגון "rule", "subcommandResults", "mode", "hook", "classifier", או "asyncAgent"
• rule_source: מקור ההגדרות של הכלל המעורב, כגון "policySettings", "userSettings", "projectSettings", "localSettings", "flagSettings", "cliArg", או "session"
• grant_scope: "once" או "session" עבור בקשה שאושרה בלי שמירת כלל לקובץ הגדרות
• circuit_breaker: בדיקת הבטיחות המובנית, כגון "dangerousRemoval", "outsideReadsBlocked", או "claudeSettingsFile"
• classifier_category: עם OTEL_LOG_TOOL_DETAILS=1, הכלל המובנה שמאחורי חסימה במצב אוטומטי, כגון "data_exfiltration"
• hook_event: "pre_tool_use" עבור hook מסוג PreToolUse, או "post_tool_use", "post_tool_use_failure", "stop", או "subagent_stop" באירועי "hook_review"
• tool_class: "bash" עבור Bash ו-Monitor, "powershell", "file" עבור Read, Edit, Write, NotebookEdit, Glob, ו-Grep, "web" עבור WebFetch ו-WebSearch, "mcp", או "other"
• tool_name: שם הכלי, כגון "Bash" עבור כלי מובנה, או "mcp_tool", "skill_tool", "dynamic_tool", או "other_tool"
• tool_source: "builtin", "mcp", או "sdk_host_builtin_mcp", כמו ב-tool_decision
• permission_mode: מצב ההרשאות של הקריאה בזמן הבדיקה: "default", "plan", "acceptEdits", "bypassPermissions", "dontAsk", או "auto"
• tool_use_id: מזהה הקריאה, כמו ב-tool_decision וב-tool_result
• sandbox_violation_count: כמה חיבורים או בקשות נפרדים מפקודת הקריאה פרוקסי הרשת של ארגז החול סירב להם, "0" עד "20" כמחרוזת. סירובים נספרים עבור פקודה בארגז חול שהסתיימה בחזית
• sandbox_enabled: "true" אם ארגז החול פעיל עבור ההפעלה, אחרת "false"

אלה המאפיינים של האירוע עצמו כאשר כלל מניעה בהגדרות מנוהלות מסרב לפקודת Bash:

{
  "event.name": "safety_event",
  "category": "managed_policy",
  "decision": "reject",
  "decision_source": "config",
  "reason_code": "rule:policySettings",
  "rule_source": "policySettings",
  "tool_class": "bash",
  "tool_name": "Bash",
  "tool_source": "builtin",
  "permission_mode": "default",
  "tool_use_id": "toolu_01ABC123...",
  "sandbox_violation_count": "0",
  "sandbox_enabled": "false"
}

#קטגוריות אירוע בטיחות

כדי למצוא סירובי פרוקסי תחת כל category, סנן לפי sandbox_violation_count שקיים ואינו "0".

#קריאות בלי אירוע בטיחות

כדי למצוא קריאות שנדחו כי אף אחד לא יכול היה לענות לבקשה בלי קטגוריה, חפש אירועי tool_decision שמדווחים "reject" עם source "config" ובלי אירוע בטיחות שחולק את ה-tool_use_id שלהם. סירובים כאלה קורים בהרצת -p בלי --permission-prompt-tool ובלי --permission-prompts none.

בדוק קריאות כמו אלה עבור אירוע tool_decision, כי אין להן אירוע בטיחות למעט אירועי "sandbox_network", "sandbox_other", או "hook_review" שנשלחים אחרי שהן רצות:

• קריאה שאושרה בבקשה בלי קטגוריה
• קריאה ש-callback מסוג canUseTool או כלי --permission-prompt-tool אישר בבקשה שרק hook מסוג PreToolUse דרש
• קריאת AskUserQuestion או ExitPlanMode, בין אם נדחתה ובין אם לא

#בקשות בלי קטגוריה

לבקשה אין קטגוריה כאשר אף ערך category לא נותן שם לבדיקה שלה, כגון בקשת מצב default לעריכה בתוך ספריית העבודה שלך.

#אירוע שינוי מצב הרשאות

נרשם כאשר מצב ההרשאות משתנה, למשל ממעבר Shift+Tab, מיציאה ממצב תכנון, או מבדיקת שער של מצב אוטומטי.

כדי לקבץ קריאות כלים לפי מצב ההרשאות שבו כל אחת נבדקה, השתמש ב-permission_mode ב-אירוע החלטת כלי.

שם האירוע: claude_code.permission_mode_changed

מאפיינים:

• כל המאפיינים הסטנדרטיים
• event.name: "permission_mode_changed"
• event.timestamp: חותמת זמן ISO 8601
• event.sequence: מונה לכל תהליך לסידור אירועים, מתואר תחת מאפייני מתאם אירועים
• from_mode: מצב ההרשאות הקודם, למשל "default", "plan", "acceptEdits", "auto", או "bypassPermissions"
• to_mode: מצב ההרשאות החדש
• trigger: מה גרם לשינוי, למשל "shift_tab", "exit_plan_mode", או "auto_gate_denied". חסר בחלק מהשינויים, כגון כאשר ה-SDK מגדיר את מצב ההרשאות דרך setPermissionMode()

#אירוע אימות

נרשם כאשר /login או /logout מסתיימים.

שם האירוע: claude_code.auth

מאפיינים:

• כל המאפיינים הסטנדרטיים
• event.name: "auth"
• event.timestamp: חותמת זמן ISO 8601
• event.sequence: מונה לכל תהליך לסידור אירועים, מתואר תחת מאפייני מתאם אירועים
• action: "login" או "logout"
• success: "true" או "false"
• auth_method: שיטת אימות, כגון "oauth"
• error_category: סוג שגיאה קטגורי כאשר הפעולה נכשלה. הודעת השגיאה הגולמית לעולם לא כלולה
• status_code: קוד מצב HTTP כמחרוזת כאשר הפעולה נכשלה עם שגיאת HTTP

#אירוע חיבור שרת MCP

נרשם כאשר שרת MCP מתחבר, מתנתק, או נכשל בחיבור.

שם האירוע: claude_code.mcp_server_connection

מאפיינים:

• כל המאפיינים הסטנדרטיים
• event.name: "mcp_server_connection"
• event.timestamp: חותמת זמן ISO 8601
• event.sequence: מונה לכל תהליך לסידור אירועים, מתואר תחת מאפייני מתאם אירועים
• status: "connected", "failed", או "disconnected"
• transport_type: תעבורת השרת, כגון "stdio", "sse", או "http"
• server_scope: ההיקף שבו השרת מוגדר, כגון "user", "project", או "local"
• duration_ms: משך ניסיון החיבור באלפיות שנייה
• error_code: קוד שגיאה כאשר החיבור נכשל
• is_plugin: true כאשר השרת מסופק על ידי תוסף, false אחרת
• plugin_id_hash (כאשר is_plugin הוא true): גיבוב יציב של שם התוסף ושוק התוספים, לקיבוץ אירועים לפי תוסף בלי לחשוף את השם. Claude Code מחשב אותו כמתואר תחת אירוע טעינת תוסף
• plugin.name (כאשר is_plugin הוא true): שם התוסף שמספק את השרת. עבור תוספי צד שלישי זו המחרוזת המילולית "third-party" אלא אם OTEL_LOG_TOOL_DETAILS=1. זה מגן על שמות תוספי צד שלישי מלהופיע ביומנים כברירת מחדל. תוספים ממקורות Anthropic רשמיים מזוהים תמיד לפי שם. המאפיינים plugin_id_hash ו-plugin.name זורמים אל מערכת הניטור שלך ואינם נשלחים ל-Anthropic
• server_name (כאשר OTEL_LOG_TOOL_DETAILS=1): שם השרת המוגדר
• error (כאשר OTEL_LOG_TOOL_DETAILS=1): הודעת השגיאה המלאה כאשר החיבור נכשל

#אירוע שגיאה פנימית

נרשם כאשר Claude Code תופס שגיאה פנימית בלתי צפויה. נרשמים רק שם מחלקת השגיאה וקוד בסגנון errno. הודעת השגיאה ומעקב המחסנית לעולם אינם כלולים. אירוע זה אינו נפלט בהרצה מול Amazon Bedrock, Agent Platform של Google Cloud, או Microsoft Foundry, או כאשר DISABLE_ERROR_REPORTING מוגדר.

שם האירוע: claude_code.internal_error

מאפיינים:

• כל המאפיינים הסטנדרטיים
• event.name: "internal_error"
• event.timestamp: חותמת זמן ISO 8601
• event.sequence: מונה לכל תהליך לסידור אירועים, מתואר תחת מאפייני מתאם אירועים
• error_name: שם מחלקת השגיאה, כגון "TypeError" או "SyntaxError"
• error_code: קוד errno של Node.js כגון "ENOENT" כאשר הוא קיים על השגיאה

#אירוע תוסף שהותקן

נרשם כאשר תוסף מסיים להתקין, גם מפקודת ה-CLI claude plugin install וגם מממשק /plugin האינטראקטיבי.

שם האירוע: claude_code.plugin_installed

מאפיינים:

• כל המאפיינים הסטנדרטיים
• event.name: "plugin_installed"
• event.timestamp: חותמת זמן ISO 8601
• event.sequence: מונה לכל תהליך לסידור אירועים, מתואר תחת מאפייני מתאם אירועים
• marketplace.is_official: "true" אם השוק הוא שוק Anthropic רשמי, "false" אחרת
• install.trigger: "cli" או "ui"
• plugin.name: שם התוסף שהותקן. עבור שווקי צד שלישי זה כלול רק כאשר OTEL_LOG_TOOL_DETAILS=1
• plugin.version: גרסת התוסף כאשר היא מוצהרת ברשומת השוק. עבור שווקי צד שלישי זה כלול רק כאשר OTEL_LOG_TOOL_DETAILS=1
• marketplace.name: השוק שממנו הותקן התוסף. עבור שווקי צד שלישי זה כלול רק כאשר OTEL_LOG_TOOL_DETAILS=1

#אירוע תוסף שנטען

נרשם פעם אחת לכל תוסף מופעל בתחילת ההפעלה. השתמש באירוע זה כדי למפות אילו תוספים פעילים ברחבי הצי שלך, כהשלמה ל-plugin_installed שמתעד את פעולת ההתקנה עצמה.

שם האירוע: claude_code.plugin_loaded

מאפיינים:

• כל המאפיינים הסטנדרטיים
• event.name: "plugin_loaded"
• event.timestamp: חותמת זמן ISO 8601
• event.sequence: מונה לכל תהליך לסידור אירועים, מתואר תחת מאפייני מתאם אירועים
• plugin.name: שם התוסף. עבור תוספים מחוץ לשוק הרשמי ולחבילה המובנית הערך הוא "third-party" אלא אם OTEL_LOG_TOOL_DETAILS=1
• marketplace.name: השוק שממנו הותקן התוסף, כאשר ידוע. מוסתר ל-"third-party" באותו תנאי כמו plugin.name
• plugin.version: גרסה ממניפסט התוסף. כלולה רק כאשר השם אינו מוסתר והמניפסט מצהיר על גרסה
• plugin.scope: קטגוריית מקור עבור התוסף: "official", "community", "org", "user-local", או "default-bundle"
• enabled_via: איך התוסף הגיע להיות מופעל: "default-enable", "org-policy", "admin-install", "seed-mount", או "user-install". הערך "admin-install" אומר שהתוסף מוגדר כנדרש או להתקנה אוטומטית עבור הארגון שלך ב-Organization settings > Plugins & skills. לפני v2.1.246, Claude Code דיווח על תוספים אלה כ-"user-install" או "seed-mount"
• plugin_id_hash: גיבוב דטרמיניסטי של שם התוסף והשוק, נשלח רק אל היצואן שהגדרת. מאפשר לספור את תוספי הצד השלישי הנפרדים שנטענו ברחבי הצי בלי לרשום את שמותיהם. עבור תוספים שמסונכרנים מ-claude.ai, Claude Code מגבב את שם התוסף עם שם השוק ש-claude.ai מדווח עבור התוסף, או עם synced אחרת. לפני v2.1.246, Claude Code לא השתמש בשם השוק ש-claude.ai מדווח בגיבוב
• has_hooks: האם התוסף תורם hooks, דרך הגדרת hook או כ-mod
• has_mcp: האם התוסף תורם שרתי MCP
• host_owned_mcp: true כאשר מארח ה-SDK מנהל את חיבורי ה-MCP של התוסף הזה ו-Claude Code דילג על קריאת הגדרת שרת ה-MCP של התוסף, false אחרת
• skill_path_count: מספר ספריות המיומנויות שהתוסף מצהיר עליהן
• command_path_count: מספר ספריות הפקודות שהתוסף מצהיר עליהן
• agent_path_count: מספר ספריות הסוכנים שהתוסף מצהיר עליהן
• safe_mode: "true" כאשר ההפעלה התחילה עם --safe-mode, "false" אחרת. במצב בטוח אירוע זה מדווח על מלאי מוגדר בלבד. הפקודות, המיומנויות, ה-hooks, ושרתי ה-MCP של התוסף אינם נטענים. דורש Claude Code v2.1.169 או גרסה מאוחרת יותר

#אירוע הפעלת מיומנות

נרשם כאשר מיומנות מופעלת, בין אם קלוד קורא לה דרך כלי ה-Skill ובין אם אתם מריצים אותה כפקודת /.

שם האירוע: claude_code.skill_activated

מאפיינים:

• כל המאפיינים הסטנדרטיים
• event.name: "skill_activated"
• event.timestamp: חותמת זמן בפורמט ISO 8601
• event.sequence: מונה לכל תהליך לסידור אירועים, כמתואר תחת מאפייני מתאם אירועים
• skill.name: שם המיומנות. למיומנויות שהוגדרו על ידי המשתמש ולמיומנויות של תוספי צד שלישי הערך הוא מציין המקום "custom_skill" אלא אם OTEL_LOG_TOOL_DETAILS=1
• invocation_trigger: איך המיומנות הופעלה ("user-slash", "claude-proactive", או "nested-skill")
• skill.source: מאיפה המיומנות נטענה (לדוגמה, "bundled", "userSettings", "projectSettings", "plugin")
• skill.kind: "workflow" כאשר המיומנות היא מיומנות תהליך עבודה. נעדר אחרת
• plugin.name (כאשר OTEL_LOG_TOOL_DETAILS=1 או שהתוסף הוא משוק רשמי): שם התוסף הבעלים כאשר המיומנות מסופקת על ידי תוסף
• marketplace.name (כאשר OTEL_LOG_TOOL_DETAILS=1 או שהתוסף הוא משוק רשמי): השוק שממנו הותקן התוסף הבעלים, כאשר המיומנות מסופקת על ידי תוסף

#אירוע אזכור עם @

נרשם כאשר Claude Code פותר אזכור @ בהנחיה. לא כל אזכור פולט אירוע: נתיבי יציאה מוקדמת כמו דחיות הרשאה, קבצים גדולים מדי, קבצים מצורפים של הפניה ל-PDF, וכשלי רישום ספריות חוזרים בלי רישום.

בכל פעם ש-Claude Code קורא הנחיה, הוא רושם לכל היותר 100 אירועים עם mention_type של "agent" ו-100 עם "mcp_resource". אזכורים מעבר לכל אחד מהגבולות עדיין נפתרים אבל לא פולטים אירוע.

שם האירוע: claude_code.at_mention

מאפיינים:

• כל המאפיינים הסטנדרטיים
• event.name: "at_mention"
• event.timestamp: חותמת זמן בפורמט ISO 8601
• event.sequence: מונה לכל תהליך לסידור אירועים, כמתואר תחת מאפייני מתאם אירועים
• mention_type: סוג האזכור ("file", "directory", "agent", "mcp_resource", "peer"). הערך "peer" אומר שאזכרתם אחת מהפעלות Claude Code האחרות שלכם. דורש Claude Code v2.1.232 או חדש יותר
• success: האם האזכור נפתר בהצלחה ("true" או "false")

#אירוע ניסיונות חוזרים של API שמוצו

נרשם פעם אחת כאשר בקשת API נכשלת אחרי יותר מניסיון אחד. נפלט יחד עם אירוע api_error הסופי.

שם האירוע: claude_code.api_retries_exhausted

מאפיינים:

• כל המאפיינים הסטנדרטיים
• event.name: "api_retries_exhausted"
• event.timestamp: חותמת זמן בפורמט ISO 8601
• event.sequence: מונה לכל תהליך לסידור אירועים, כמתואר תחת מאפייני מתאם אירועים
• model: המודל שבשימוש
• error: הודעת השגיאה הסופית
• status_code: קוד מצב HTTP כמספר. נעדר לשגיאות שאינן HTTP.
• total_attempts: מספר הניסיונות הכולל שבוצעו
• total_retry_duration_ms: זמן שעון קיר כולל על פני כל הניסיונות
• speed: "fast" או "normal"

#אירוע הוק שנרשם

נרשם פעם אחת לכל הוק מוגדר בתחילת הפעלה. השתמשו באירוע זה כדי לערוך מלאי של ההוקים הפעילים בכל הצי שלכם, כהשלמה לאירועי hook_execution_start ו-hook_execution_complete לכל ביצוע.

שם האירוע: claude_code.hook_registered

מאפיינים:

• כל המאפיינים הסטנדרטיים
• event.name: "hook_registered"
• event.timestamp: חותמת זמן בפורמט ISO 8601
• event.sequence: מונה לכל תהליך לסידור אירועים, כמתואר תחת מאפייני מתאם אירועים
• hook_event: סוג אירוע ההוק, כמו "PreToolUse" או "PostToolUse"
• hook_type: סוג מימוש ההוק: "command", "prompt", "mcp_tool", "http", או "agent"
• hook_source: איפה ההוק מוגדר: "userSettings", "projectSettings", "localSettings", "flagSettings", "policySettings", או "pluginHook"
• safe_mode: "true" כאשר ההפעלה הופעלה עם --safe-mode, "false" אחרת. דורש Claude Code v2.1.169 או חדש יותר
• hook_matcher (כאשר OTEL_LOG_TOOL_DETAILS=1): מחרוזת ההתאמה מתצורת ההוק, כאשר אחת מוגדרת
• plugin.name (כאשר hook_source הוא "pluginHook"): שם התוסף התורם. לתוספים מחוץ לשוק הרשמי ולחבילה המובנית הערך הוא "third-party" אלא אם OTEL_LOG_TOOL_DETAILS=1
• plugin_id_hash (כאשר hook_source הוא "pluginHook"): גיבוב דטרמיניסטי של שם התוסף והשוק, שנשלח רק אל היצואן שהגדרתם. מאפשר לספור תוספים תורמים נפרדים בלי לרשום את שמותיהם. Claude Code מחשב אותו כמתואר תחת אירוע תוסף שנטען

#אירוע תחילת ביצוע הוק

נרשם כאשר הוק אחד או יותר מתחילים להתבצע לאירוע הוק.

שם האירוע: claude_code.hook_execution_start

מאפיינים:

• כל המאפיינים הסטנדרטיים
• event.name: "hook_execution_start"
• event.timestamp: חותמת זמן בפורמט ISO 8601
• event.sequence: מונה לכל תהליך לסידור אירועים, כמתואר תחת מאפייני מתאם אירועים
• hook_event: סוג אירוע הוק, כמו "PreToolUse" או "PostToolUse"
• hook_name: שם ההוק המלא כולל התאמה, כמו "PreToolUse:Write"
• num_hooks: מספר פקודות ההוק התואמות
• managed_only: "true" כאשר רק הוקים של מדיניות מנוהלת מותרים
• hook_source: "policySettings" או "merged"
• safe_mode: "true" כאשר ההפעלה הופעלה עם --safe-mode, "false" אחרת. דורש Claude Code v2.1.169 או חדש יותר
• hook_definitions: תצורת הוק שעברה סריאליזציה ל-JSON. נכלל רק כאשר גם מעקב בטא מפורט וגם OTEL_LOG_TOOL_DETAILS=1 מופעלים

#אירוע השלמת ביצוע הוק

נרשם כאשר כל ההוקים לאירוע הוק סיימו.

שם האירוע: claude_code.hook_execution_complete

מאפיינים:

• כל המאפיינים הסטנדרטיים
• event.name: "hook_execution_complete"
• event.timestamp: חותמת זמן בפורמט ISO 8601
• event.sequence: מונה לכל תהליך לסידור אירועים, כמתואר תחת מאפייני מתאם אירועים
• hook_event: סוג אירוע הוק
• hook_name: שם ההוק המלא כולל התאמה
• num_hooks: מספר פקודות ההוק התואמות
• num_success: מספר שהושלמו בהצלחה
• num_blocking: מספר שהחזירו החלטת חסימה
• num_non_blocking_error: מספר שנכשלו בלי חסימה
• num_cancelled: מספר שבוטלו לפני השלמה
• total_duration_ms: משך שעון קיר של כל ההוקים התואמים
• stdout_chars: סך התווים של stdout על פני ההוקים התואמים שהצליחו. דורש Claude Code v2.1.280 או חדש יותר
• additional_context_chars: סך התווים של additionalContext שהוחזרו על ידי ההוקים התואמים. דורש Claude Code v2.1.280 או חדש יותר
• system_message_chars: סך התווים של systemMessage שהוחזרו על ידי ההוקים התואמים. דורש Claude Code v2.1.280 או חדש יותר
• initial_user_message_chars: סך התווים של initialUserMessage שהוחזרו על ידי ההוקים התואמים. דורש Claude Code v2.1.280 או חדש יותר
• num_outputs_persisted: מספר פלטי הוק מעל תקרת 10,000 התווים ש-Claude Code שמר לקובץ. דורש Claude Code v2.1.280 או חדש יותר
• managed_only: "true" כאשר רק הוקים של מדיניות מנוהלת מותרים
• hook_source: "policySettings" או "merged"
• safe_mode: "true" כאשר ההפעלה הופעלה עם --safe-mode, "false" אחרת. דורש Claude Code v2.1.169 או חדש יותר
• hook_definitions: תצורת הוק שעברה סריאליזציה ל-JSON. נכלל רק כאשר גם מעקב בטא מפורט וגם OTEL_LOG_TOOL_DETAILS=1 מופעלים

#אירוע מדדי תוסף הוק

נרשם כאשר הוק של תוסף משוק רשמי פולט מדדים לכל הפעלה. רק תוספים שהותקנו משוק Anthropic רשמי יכולים לפלוט אלה. תוספי שוק צד שלישי והוקים שהוגדרו על ידי המשתמש לא פולטים לאירוע זה. השתמשו באירוע זה כדי לנטר התנהגות תוסף כמו שיעורי ממצאים, עלויות ומשכים ממחסנית התצפיתיות שלכם.

שם האירוע: claude_code.hook_plugin_metrics

מאפיינים:

• כל המאפיינים הסטנדרטיים
• event.name: "hook_plugin_metrics"
• event.timestamp: חותמת זמן בפורמט ISO 8601
• event.sequence: מונה לכל תהליך לסידור אירועים, כמתואר תחת מאפייני מתאם אירועים
• plugin_id: מזהה תוסף בצורה <name>@<marketplace>
• hook_event: סוג אירוע ההוק שפלט את המדדים
• עד 20 מפתחות מדד שנפלטו על ידי התוסף. השמות תואמים ל-^[a-z][a-z0-9_]{0,39}$. הערכים הם בוליאני או מספר.

#אירוע דחיסה

נרשם כאשר דחיסת השיחה מסתיימת.

שם האירוע: claude_code.compaction

מאפיינים:

• כל המאפיינים הסטנדרטיים
• event.name: "compaction"
• event.timestamp: חותמת זמן בפורמט ISO 8601
• event.sequence: מונה לכל תהליך לסידור אירועים, כמתואר תחת מאפייני מתאם אירועים
• trigger: "auto" או "manual"
• success: "true" או "false"
• duration_ms: משך הדחיסה
• pre_tokens: ספירת אסימונים משוערת לפני הדחיסה
• post_tokens: ספירת אסימונים משוערת אחרי הדחיסה
• error: הודעת שגיאה כאשר הדחיסה נכשלה
• precompute_reuse: מוגדר רק כאשר trigger הוא "manual", או כאשר trigger הוא "auto" לדחיסת סרק בהפעלת מסוף אינטראקטיבית. דחיסה אוטומטית יכולה להכין סיכום ברקע לפני שחלון ההקשר מתמלא, והמאפיין הזה רושם אם הדחיסה עשתה שימוש חוזר בסיכום שהוכן. "hit" אומר שנעשה בו שימוש חוזר. "miss_custom_instructions", "miss_hook", ו-"miss_not_ready" נותנים את הסיבה שסיכום חדש חושב במקום זה

#אירוע סוכן משנה שהושלם

נרשם כאשר סוכן משנה מסיים ומחזיר את התוצאה שלו לשיחה שהתחילה אותו. השתמשו בו כדי לסכם שימוש בכלים וזמן ריצה לפי סוג סוכן משנה. לסיכומי אסימונים או עלות, השתמשו במונה האסימונים ובמונה העלות המסוננים ל-query_source "subagent", כי total_tokens של אירוע זה מכסה רק את הבקשה הסופית. הקטגוריה "subagent" גם סופרת בקשות מהוקים מבוססי סוכן, שאינם פולטים אירוע סוכן משנה.

שם האירוע: claude_code.subagent_completed

מאפיינים:

• כל המאפיינים הסטנדרטיים
• event.name: "subagent_completed"
• event.timestamp: חותמת זמן בפורמט ISO 8601
• event.sequence: מונה לכל תהליך לסידור אירועים, כמתואר תחת מאפייני מתאם אירועים
• agent_type: סוג סוכן המשנה. שמות סוכנים מובנים וסוכנים מתוספי שוק רשמי מופיעים כלשונם. שמות סוכנים אחרים מוחלפים ב-"custom" אלא אם OTEL_LOG_TOOL_DETAILS=1 מוגדר
• agent.source: מאיפה הגיעה הגדרת הסוכן: built-in, plugin, או מקור ההגדרות שהגדיר סוכן מותאם, כמו userSettings או projectSettings
• is_built_in: האם סוכן המשנה הוא סוג סוכן מובנה
• is_async: האם סוכן המשנה רץ ברקע
• total_tokens: טביעת האסימונים של בקשת ה-API הסופית של סוכן המשנה: אסימוני הקלט, יצירת המטמון, קריאת המטמון והפלט של אותה בקשה אחת, בערך גודל ההקשר של סוכן המשנה בהשלמה. לא סכום על פני הריצה
• total_tool_uses: מספר קריאות הכלים שסוכן המשנה ביצע על פני כל הריצה
• duration_ms: זמן ריצה באלפיות שנייה
• model: המודל שלסוכן המשנה נקבע לרוץ
• final_model: המודל שהפיק את התגובה הסופית של סוכן המשנה, ששונה מ-model אחרי החלפה באמצע הריצה כמו נפילה חלופית
• model_swapped: האם יותר ממודל אחד שירת את בקשות סוכן המשנה
• plugin_id_hash, plugin.name: נוכחים לסוכנים שסופקו על ידי תוסף. שמות תוספי שוק רשמי מופיעים כלשונם. שמות תוספים אחרים מוחלפים ב-"third-party" אלא אם OTEL_LOG_TOOL_DETAILS=1 מוגדר

#אירוע סקר משוב

נרשם כאשר סקר איכות הפעלה מוצג או נענה. ראו סקרי איכות הפעלה למה הסקרים אוספים ואיך לשלוט בהם.

שם האירוע: claude_code.feedback_survey

מאפיינים:

• כל המאפיינים הסטנדרטיים
• event.name: "feedback_survey"
• event.timestamp: חותמת זמן בפורמט ISO 8601
• event.sequence: מונה לכל תהליך לסידור אירועים, כמתואר תחת מאפייני מתאם אירועים
• event_type: אירוע מחזור חיים של הסקר, לדוגמה "appeared", "responded", או "transcript_prompt_appeared"
• appearance_id: מזהה ייחודי שמקשר את האירועים שנפלטו למופע סקר אחד
• survey_type: איזה סקר הפיק את האירוע. "session" הוא הנחיית הדירוג "How is Claude doing?"
• response: הבחירה של המשתמש באירועי responded
• enabled_via_override: true כאשר CLAUDE_CODE_ENABLE_FEEDBACK_SURVEY_FOR_OTEL מוגדר. נפלט כבוליאני, לא כמחרוזת. נוכח באירועי סקר session. סננו לפי מאפיין זה כדי לאשר שהעקיפה חלה על פני צי

#אירוע סריקת שמירה

נרשם פעם אחת לכל הרצה של סריקת ניקוי השמירה, שמוחקת תמלילי שיחה ונתוני יישום אחרים ישנים יותר מההגדרה cleanupPeriodDays. Claude Code מריץ את הסריקה ברקע לכל היותר פעם אחת לכל שיחה, והרצה שלא מוחקת דבר עדיין פולטת את האירוע. אם Claude Code הריץ את הסריקה בשיחה כלשהי באותה מכונה ב-24 השעות האחרונות, הוא מעכב את הסריקה של השיחה הזו בלפחות 10 דקות, ולכן שיחה שיוצאת מוקדם יותר לא פולטת דבר. כשמריצים את claude -p עם --bare, Claude Code לא מריץ את הסריקה ולא פולט דבר.

כמו כל אירוע OTel בדף הזה, הוא הולך רק ל-backend של הטלמטריה שמגדירים. דורש Claude Code v2.1.227 או מאוחר יותר.

כש-Claude Code לא יכול לקבוע בבטחה את תקופת השמירה, הוא משהה את הסריקה ופולט את האירוע עם result מוגדר ל-"skipped" ו-skip_reason. כשהגדרות מנוהלות מגדירות את cleanupPeriodDays, הערך המנוהל קובע את תקופת השמירה והסריקה רצה גם כשקובץ הגדרות בטווח בעדיפות נמוכה יותר שבור או לא תקין. כשלא ניתן לקרוא את managed-settings.json עצמו, Claude Code עדיין משהה את הסריקה אלא אם השכבה המנוהלת מספקת את cleanupPeriodDays ממקום אחר, למשל הגדרות מנוהלות בשרת או drop-in של managed-settings.d/ ליד הקובץ השבור. מאפייני מונה המחיקה קיימים רק כש-result הוא "complete".

שם האירוע: claude_code.retention_sweep

מאפיינים:

• כל המאפיינים הסטנדרטיים
• event.name: "retention_sweep"
• event.timestamp: חותמת זמן ISO 8601
• event.sequence: מונה לכל תהליך לסידור אירועים, מתואר תחת מאפייני מתאם אירועים
• result: "complete" כשהסריקה רצה, "skipped" כש-Claude Code השהה אותה
• period_days: ערך cleanupPeriodDays מההגדרות הממוזגות, בימים, או 30 כשאף מקור לא מגדיר אותו. באירועים שהודלגו, הערך שהסריקה הייתה משתמשת בו, מחושב ממקורות ההגדרות ש-Claude Code הצליח לקרוא
• used_default: "true" כשאף מקור הגדרות קריא לא מגדיר את cleanupPeriodDays, "false" אחרת. באירועים שהושלמו, "true" אומר שברירת המחדל של 30 יום חלה
• skip_reason: למה Claude Code השהה את הסריקה. קיים רק כש-result הוא "skipped":
  • "user_source_disabled": הגדרות המשתמש מוחרגות, למשל על ידי הדגל --setting-sources או האפשרות settingSources של ה-SDK, ואף מקור מופעל לא מספק את cleanupPeriodDays
  • "settings_unknowable": לא ניתן היה לקרוא או לנתח קובץ הגדרות, ולכן cleanupPeriodDays או desktopSessionCleanupPeriodDays עשויים להיות מוגדרים לערך ש-Claude Code לא יכול לראות
  • "settings_invalid_key_set": להגדרות יש שגיאות אימות ו-cleanupPeriodDays או desktopSessionCleanupPeriodDays מוגדר במפורש, ולכן חזרה לברירת המחדל עלולה למחוק או לשמור קבצים בניגוד להגדרה הזו
  • "remote_settings_unknowable": שיחה בלשונית Code של Claude Desktop בפריסה של צד שלישי ביקשה הגדרות מנוהלות בשרת. היא לא קיבלה תשובה שמישה, ולכן cleanupPeriodDays עשוי להיות מוגדר לערך ש-Claude Code לא יכול לראות
• transcripts_deleted: מספר תמלילי השיחה, קבצי ~/.claude/projects/*/*.jsonl ברמה העליונה, שהסריקה מחקה
• transcripts_exempted_desktop: מספר התמלילים שעברו את תקופת השמירה והסריקה שמרה לפי הכלל של Claude Desktop ו-Cowork. אלה לא נספרים ב-files_past_cutoff. דורש Claude Code v2.1.248 או מאוחר יותר
• session_files_deleted: מספר הפריטים שסריקת קבצי השיחה מחקה: תמלילים בתוספת קבצים נלווים לכל שיחה כגון sidecars, הקלטות ותוצאות כלים
• artifacts_deleted: סך הפריטים שהסריקה מחקה בתיקיות הנתונים שהיא מכסה, כולל קבצי השיחה. חלק מהסריקות סופרות עץ תיקיות שלם שהוסר כפריט אחד, וכמה מעברי ניקוי לא תורמים למונה, ולכן יש להתייחס לערך כרצפה ולא כספירת קבצים מדויקת
• files_retained_fresh: קבצים שנבדקו והושארו במקום כי הם עדיין בתוך תקופת השמירה. רק סריקות לכל קובץ סופרות אותם, ולכן הערך הוא רצפה. ערך שאינו אפס הוא המצב היציב הרגיל
• files_past_cutoff: קבצים ישנים יותר מתקופת השמירה שהסריקה נכשלה במחיקתם, למשל בגלל שגיאת הרשאה או קובץ פתוח. הספירה כוללת גם כל תיקייה ישנה שהסריקה מוצאת תחת skills/synced/ או plugins/synced/, בין שהיא מעבירה את התיקייה לפח ובין שלא. מלבד התיקיות האלה, ערך מעל אפס אומר שקבצים שרדו מעבר לתקופת השמירה שהוגדרה. אפס אינו הוכחה שאף אחד לא שרד, כי הסרה שנכשלה של תיקייה שלמה נספרת ב-error_count במקום זאת
• error_count: מספר השגיאות שהסריקה נתקלה בהן בזמן רישום או מחיקת קבצים

#אירוע הגדרות מנוהלות שנפתרו

נרשם עם ההגדרות המנוהלות ששיחה פתרה: פעם אחת בתחילת השיחה, שוב כשמצב ההגדרות המנוהלות או עוזר המדיניות משתנה במהלך השיחה, וכש-Claude Code מסרב להתחיל או מסיים את השיחה מאחת הסיבות שמאפיין error.type מפרט. השתמשו באירוע הזה כדי למצוא מכונות שרצות על מקור מנוהל לא צפוי, מכונות שעוזר המדיניות שלהן נכשל, ואת הסיבה שמכונה סירבה להתחיל. דורש Claude Code v2.1.274 או מאוחר יותר.

כברירת מחדל, האירוע נושא את המקורות המנוהלים ואת מצב עוזר המדיניות, אבל לא את ההגדרות עצמן. כדי להוסיף את המאפיין המצונזר managed_settings.settings ואת התקציר managed_settings.resolved_sha256, הגדירו את OTEL_LOG_MANAGED_SETTINGS=1:

• הגדירו אותו בבלוק env של הגדרות מנוהלות, הגדרות משתמש, או --settings, או בסביבה שממנה מפעילים את Claude Code. ערך בהגדרות פרויקט או מקומיות לא מפעיל אותו, כי מאגר משובט יכול לכתוב אותן.
• הגדרות מנוהלות בשרת יכולות להגדיר אותו בלי להציג את תיבת דו-השיח לאישור אבטחה, כי המשתנה רק מוסיף את המדיניות המצונזרת של הארגון עצמו לאירוע שהארגון כבר מקבל.

בשיחה אינטראקטיבית בתיקייה שעדיין לא נתתם בה אמון, Claude Code לא מייצא את אירוע הסירוב.

שם האירוע: claude_code.managed_settings_resolved

מאפיינים:

• כל המאפיינים הסטנדרטיים

• event.name: "managed_settings_resolved"

• event.timestamp: חותמת זמן ISO 8601

• event.sequence: מונה לכל תהליך לסידור אירועים, מתואר תחת מאפייני מתאם אירועים

• managed_settings.trigger: "startup" לאירוע תחילת השיחה, "change" כשההגדרות המנוהלות או מצב עוזר המדיניות השתנו בהמשך השיחה, או "refused" כשמדיניות של הגדרות מנוהלות עצרה את השיחה. Claude Code שולח אירוע change רק כשמאפיין שונה מהאירוע האחרון שהוא שלח, וערך הגדרה שהשתנה נספר גם כש-OTEL_LOG_MANAGED_SETTINGS כבוי

• error.type: למה Claude Code עצר את השיחה. קיים רק באירועי refused:

  • "helper_failed": הרצת עוזר מדיניות נכשלה
  • "policy_invalid": ההגדרות המנוהלות מכילות שגיאה שעוצרת את Claude Code מהתחלה, או שמקור מנהל נכשל בטעינה מסיבה שאינה קריאה שנדחתה, ולכן Claude Code לא יכול לבדוק התחברות ארגונית או אכיפת ספק
  • "provider_not_allowed": השיחה הייתה משתמשת בספק API, או שולחת תעבורה של ספק למארח, שרשימת allowedProviders המנוהלת לא מתירה. דורש Claude Code v2.1.285 או מאוחר יותר
  • "consent_rejected": המשתמש דחה את תיבת דו-השיח לאישור אבטחה להגדרות מנוהלות בשרת
  • "force_refresh_failed": שליפת ההגדרות ש-forceRemoteSettingsRefresh דורש נכשלה
  • "gateway_rejected": שער יישומי Claude ענה לטעינת ההגדרות המנוהלות ב-HTTP 403
  • "version_below_minimum": גרסה זו של Claude Code נמוכה מ-requiredMinimumVersion או גבוהה מ-requiredMaximumVersion
  • "_OTHER": טעינת ההגדרות המנוהלות של שער יישומי Claude נכשלה מסיבה אחרת

• managed_settings.sources: כל מקור מנוהל שמספק לפחות מפתח מדיניות אחד, מהעדיפות הגבוהה לראשונה, כולל מקורות שהמפתחות שלהם לא נכנסים לתוקף תחת first-wins. הערכים הם "remote", "plist" או "hklm" למדיניות MDM או ברמת מערכת ההפעלה, "file" לקבצי הגדרות מנוהלות ול-drop-ins, "parent" כשמארח מטמיע מספק הגדרות, ו-"hkcu" לערך הרישום HKCU של Windows כש-Claude Code קורא אותו. מקור שנושא רק מפתחות בקרה, או ש-Claude Code לא הצליח לקרוא, לא מופיע ברשימה. נפלט כמערך מחרוזות, ריק כשאף מקור מנוהל לא מספק מפתח מדיניות

• managed_settings.source_behavior: ערך managedSourcesBehavior ש-Claude Code קרא, "first-wins" או "merge". "first-wins" כשאף מקור לא מגדיר את המפתח

• managed_settings.helper.state: מצב עוזר המדיניות שמקור ה-MDM או הקובץ שנבחר מגדיר:

  • "ok": הפלט של העוזר משמש כהגדרות המנוהלות
  • "bad_path", "not_a_file", "exit_nonzero", "timed_out", "oversize", "parse_failed", "envelope_invalid", או "schema_rejected": ההרצה האחרונה של העוזר נכשלה. כשלי עוזר מתארים את המקרים
  • "none": לא מוגדר עוזר, או שהמקור שמגדיר אותו אינו מדיניות MDM או קובץ הגדרות מנוהלות

• managed_settings.helper.applied: "output" בזמן שהפלט של העוזר עצמו משמש כהגדרות המנוהלות, "none" כשלא

• managed_settings.helper.entry: "policyHelper" כש-Claude Code בחר policyHelper. חסר כשלא נבחר עוזר

• managed_settings.helper.path: ה-path המוגדר של העוזר. קיים בכל פעם ש-Claude Code בחר עוזר, בין ש-OTEL_LOG_MANAGED_SETTINGS מוגדר ובין שלא

• managed_settings.resolved_sha256 (כש-OTEL_LOG_MANAGED_SETTINGS=1): SHA-256 של ההגדרות המנוהלות שנפתרו לפני צנזור, בסריאליזציה כ-JSON עם מפתחות ממוינים רקורסיבית ובלי רווח לבן. מכונות עם אותו תקציר מריצות את אותה מדיניות. Claude Code שולח את התקציר רק עם ההצטרפות, כי מדיניות קצרה ניתנת לשחזור על ידי גיבוב של ניחושים. חסר כשלא נפתרו הגדרות מנוהלות, ובאירועי refused

• managed_settings.settings (כש-OTEL_LOG_MANAGED_SETTINGS=1): השמות והצורה של ההגדרות המנוהלות שנפתרו כמחרוזת JSON, עם ערכים מצונזרים. חסר באירועי refused. Claude Code בונה אותו מסכמת ההגדרות שלו:

  • שם הגדרה שהסכמה מצהירה עליו מיוצא, ומפתח שהיא לא מצהירה עליו מושמט
  • ערכים בוליאניים, מספרים וערכי מחרוזת שהסכמה מגבילה לקבוצת אפשרויות קבועה, כגון permissions.defaultMode, מיוצאים כפי שהם. sandbox.network.httpProxyPort ו-sandbox.network.socksProxyPort מיוצאים כ-"[REDACTED]"
  • כל מחרוזת אחרת, כגון model, apiKeyHelper, כל ערך env, כל URL וכל פקודה, מיוצאת כ-"[REDACTED]"
  • שמות הרשומות במפות, כגון שמות משתני env ומזהי תוספים, מיוצאים כפי שהם. הגדרה שהסכמה לא מקלידה את הרשומות שלה, כגון vimInsertModeRemaps, מיוצאת כ-"[REDACTED]" יחיד, ו-sandbox.ignoreViolations מיוצא כרשימה של רשימות הנתיבים שלו בלי תבניות הפקודה
  • רשימה שומרת על אורכה, וכל רשומה מצונזרת לפי אותם כללים
  • כלל permissions.allow, permissions.deny או permissions.ask מיוצא כשם הכלי עם תוכן מצונזר, כגון Read([REDACTED]), כשהכלי מובנה בגרסה זו של Claude Code או שהוא הפניה mcp__ כגון mcp__jira__create_issue. כל כלל אחר מיוצא כ-"[REDACTED]"
  • Hooks פועלים לפי אותם כללים, ולכן שדות של אפשרות קבועה ושדות מספריים כגון type ו-timeout מוצגים, בעוד שכל פקודה, URL, matcher ותנאי if מיוצאים כ-"[REDACTED]"

  לדוגמה, הגדרות מנוהלות עם apiKeyHelper, שני משתני env וכלל deny מיוצאות כ-{"apiKeyHelper":"[REDACTED]","env":{"HTTPS_PROXY":"[REDACTED]","CLAUDE_CODE_ENABLE_TELEMETRY":"[REDACTED]"},"permissions":{"deny":["Read([REDACTED])"]}}.

  Claude Code חותך את הערך ב-8 KB של UTF-8, והערך החתוך אינו JSON תקין

• managed_settings.settings_truncated (כש-managed_settings.settings קיים): true כש-Claude Code חתך את managed_settings.settings ב-8 KB, false אחרת. נפלט כבוליאני, לא כמחרוזת

#פירוש נתוני מדדים ואירועים

המדדים והאירועים המיוצאים תומכים במגוון ניתוחים:

#ניטור שימוש

#ניטור עלויות

המדד claude_code.cost.usage עוזר ב:

• מעקב אחרי מגמות שימוש בין צוותים או אנשים
• זיהוי סשנים עם שימוש גבוה לצורך אופטימיזציה
• ייחוס הוצאה למיומנויות, לתוספים או לסוגי תת-סוכנים ספציפיים באמצעות המאפיינים skill.name, plugin.name ו-agent.name

[!NOTE]

מדדי העלות הם קירוב. לנתוני חיוב רשמיים, ראו ניהול עלויות לארגון.

Claude Code סופר כל תגובת סטרימינג למדדי העלות והטוקנים בדיוק פעם אחת, כולל כאשר שער או פרוקסי מאחורי ANTHROPIC_BASE_URL מזרים את השימוש בהדרגה על פני כמה מסגרות.

#התראות ופילוח

התראות נפוצות שכדאי לשקול:

• קפיצות בעלות
• צריכת טוקנים חריגה
• נפח סשנים גבוה ממשתמשים ספציפיים

אפשר לפלח את כל המדדים לפי המאפיינים הסטנדרטיים. המאפיין model זמין ב-claude_code.token.usage, ב-claude_code.cost.usage וב-claude_code.lines_of_code.count.

פירוקים לפי מודל של קומיטים ניתנים רק לקירוב על ידי צירוף מול מדדי הטוקנים או העלות על session.id, מכיוון שסשן אחד יכול להשתרע על כמה מודלים. סננו את צד הטוקנים או העלות לשורות שבהן query_source הוא "main", כדי שבקשות עזר ובקשות תת-סוכן לא ייחסו את הקומיטים של הסשן למודל שלא יצר אותם.

#זיהוי מיצוי ניסיונות חוזרים

Claude Code מבצע ניסיונות חוזרים פנימיים לבקשות API שנכשלו, ופולט אירוע claude_code.api_error יחיד רק אחרי שהוא מוותר, כך שהאירוע עצמו הוא האות הסופי לאותה בקשה. ניסיונות ביניים חוזרים לא נרשמים כאירועים נפרדים.

המאפיין attempt באירוע מתעד את מספר הניסיונות. ל-CLAUDE_CODE_MAX_RETRIES יש ברירת מחדל של 10 והוא מוגבל ל-15. כש-CLAUDE_CODE_RETRY_WATCHDOG מוגדר, ברירת המחדל גבוהה יותר ואין מגבלה.

כשהבקשה ממצת את כל הניסיונות החוזרים בשגיאה חולפת, attempt הוא לכל היותר אחד יותר מהמגבלה האפקטיבית הזו: 11 כברירת מחדל.

ערך נמוך יותר עדיין יכול לומר שהניסיונות החוזרים אזלו: attempt מתחיל מחדש מ-1 בכל פעם ש-Claude Code מנפיק את הבקשה מחדש אחרי כשל בסטרימינג.

כדי להבחין בין סשן שהתאושש לסשן שנתקע, קבצו אירועים לפי session.id ובדקו אם קיים אירוע api_request מאוחר יותר אחרי השגיאה.

#ניתוח אירועים

נתוני האירוע מתארים כל אינטראקציה של Claude Code בפירוט:

דפוסי שימוש בכלים: נתחו אירועי תוצאת כלי כדי לזהות:

• הכלים שבשימוש בתדירות הגבוהה ביותר
• שיעורי הצלחה של כלים
• זמני ביצוע ממוצעים של כלים
• דפוסי שגיאה לפי סוג כלי

ניטור ביצועים: עקבו אחרי משכי בקשות API ואחרי זמני ביצוע של כלים כדי לזהות צווארי בקבוק בביצועים.

#מיפוי טוקני קלט למוסכמות הסמנטיות של OpenTelemetry GenAI

Claude Code מייצא ספירות של טוקני קלט כפי שהן מופיעות בבלוק ה-usage בתגובת ה-API, ולכן הערכים האלה לא כוללים טוקנים שנקראו מ-מטמון הפרומפט או נכתבו אליו:

• input_tokens ב-span claude_code.llm_request ובאירוע api_request
• הסוג "input" של המדד claude_code.token.usage

Claude Code לא מגדיר מאפייני gen_ai.usage.*. המוסכמות הסמנטיות של OpenTelemetry GenAI קובעות ש-gen_ai.usage.input_tokens צריך לכלול טוקנים שנקראו מהמטמון וטוקנים שנכתבו אליו. כדי לחשב את הסכום הזה:

• מה-span או מהאירוע: חברו את input_tokens, את cache_read_tokens ואת cache_creation_tokens
• מהמדד claude_code.token.usage: חברו את הסוגים "input", "cacheRead" ו-"cacheCreation" שלו

המוסכמות גם מגדירות מאפיינים נפרדים לקריאות מהמטמון ולכתיבות למטמון:

• cache_read_tokens ממופה אל gen_ai.usage.cache_read.input_tokens
• cache_creation_tokens ממופה אל gen_ai.usage.cache_write.input_tokens. גרסאות ישנות יותר של המוסכמות נותנות למאפיין כתיבת המטמון את השם gen_ai.usage.cache_creation.input_tokens, לכן השתמשו בשם שה-backend שלכם מצפה לו.

#ביקורת אירועי אבטחה

אירועי OpenTelemetry הם מקור נתוני הביקורת לפעילות של Claude Code. כל אירוע נושא מאפייני זהות שמקשרים קריאות כלים, פעילות MCP והחלטות הרשאה אל המשתמש שהפעיל אותם. מייצא הלוגים של OTLP יכול להעביר את האירועים האלה לכל פלטפורמת Security Information and Event Management (SIEM) עם מקלט OTLP, או אל OpenTelemetry Collector שמעביר אל ה-SIEM שלך.

#שיוך פעולות למשתמשים

המאפיינים הסטנדרטיים בכל אירוע כוללים את זהות המשתמש המאומת: user.email, user.account_uuid, user.account_id, ו-organization.id כאשר נכנסים עם חשבון Claude או, בסשן ענן, כאשר האישורים של הסשן עצמו נושאים אותם, וגם user.id ו-session.id של הסשן. user.id הוא מזהה ברמת ההתקנה, למעט בסשנים שמחוברים אל Claude apps gateway דרך /login, שם הוא נושא ה-IdP מהאסימון שהשער הנפיק.

בסשן שמפתח מתחיל, קריאות כלי MCP, פקודות Bash ועריכות קבצים משויכות אפוא למפתח הזה. Claude Code לא פועל שם תחת חשבון שירות נפרד. הזהות שנרשמת בכל אירוע היא חשבון Claude של המפתח עצמו, או זהות ה-IdP של המפתח בסשן Claude apps gateway. בסשני ערוץ Claude Tag, Claude עובד בתור הזהות המשותפת של הארגון שלך.

כאשר Claude Code מאמת עם מפתח API ישיר, או מול Amazon Bedrock, Agent Platform של Google Cloud, או Microsoft Foundry, אין חשבון Claude בסשן ורק user.id ו-session.id מאוכלסים. בפריסות האלה, צרף זהות משתמש בעצמך עם OTEL_RESOURCE_ATTRIBUTES, שמוגדר לכל משתמש דרך קובץ ההגדרות המנוהלות או עטיפת הפעלה. סשני Claude apps gateway לא צריכים אף אחד מאלה: ראה מאפיינים סטנדרטיים לזהות שהייצוא שלהם נושא.

export OTEL_RESOURCE_ATTRIBUTES="[email protected],enduser.directory_id=S-1-5-21-..."

#ביקורת פעילות MCP

כדי ללכוד פעילות שרת MCP עם פירוט קריאה מלא, הפעל את מייצא הלוגים והגדר OTEL_LOG_TOOL_DETAILS=1. כל פעולת MCP אז מייצרת אירועים מובנים שנושאים את שם השרת, שם הכלי וארגומנטי הקריאה לצד מאפייני הזהות הסטנדרטיים:

בלי OTEL_LOG_TOOL_DETAILS, האירועים האלה משמיטים את פירוט הזיהוי:

• tool_result: שומר mcp_server_scope ו-tool_name שמושתק למחרוזת המילולית "mcp_tool" עבור שרתים שהמשתמש הגדיר, ומשמיט תוכן ארגומנטים. עבור השרתים המובנים של Claude Desktop, בסשנים ש-Claude Desktop מחזיק, הוא גם שומר את הזוג mcp_server_name/mcp_tool_name בתוך tool_parameters, אותו חריג שכתב המארח כמו ב-tool_decision
• tool_decision: שומר tool_source ו-tool_name שמושתק למחרוזת המילולית "mcp_tool" עבור שרתים שהמשתמש הגדיר, ומשמיט תוכן ארגומנטים. עבור השרתים המובנים של Claude Desktop, בסשנים ש-Claude Desktop מחזיק, הוא גם שומר את הזוג mcp_server_name/mcp_tool_name בתוך tool_parameters
• mcp_server_connection: משמיט server_name ואת הודעת השגיאה, אבל שומר is_plugin, plugin_id_hash, ו-plugin.name, כאשר שמות תוספים שאינם של Anthropic מושתקים למחרוזת המילולית "third-party", כך ששרתים שמספק תוסף נשארים ניתנים להבחנה בלי רישום מפורט

#מיפוי שאלות אבטחה לאירועים

בעת בניית כללי זיהוי, חפש את האות שברצונך לנטר ושאל את ה-backend שלך על האירוע והמאפיינים המתאימים:

Claude Code פולט רק את זרם האירועים הגולמי. זיהוי חריגות, קביעת קו בסיס, מתאם בין סשנים והתראות הם באחריות ה-SIEM או ה-backend של התצפיתיות שלך.

#מיפוי נתיבי יציאה לבקרות מנוהלות ולאירועים

הטבלה מצמידה נתיבים שיכולים להוציא תוכן סשן ממכונה, בתוספת שמירה מקומית, אל מפתחות ההגדרות המנוהלות שמגבילים אותם ואל האירועים שרושמים אותם. לגבי מה ש-Claude Code עצמו שולח אל Anthropic, למשל דיווחי /feedback, ראה שימוש בנתונים. השמות מקשרים אל רשומות העיון שלהם, שנותנות את הערכים ואת ברירות המחדל.

הרשומות allowedHttpHookUrls, managed-mcp.json, ורשומות אירועי hook צריכות יותר ממה שהטבלה מראה:

• allowedHttpHookUrls: רשומות מתמזגות בין קובצי ההגדרות, כך שמפתח יכול להוסיף לרשימה מנוהלת ריקה. allowManagedHooksOnly קובע אילו hooks רצים
• managed-mcp.json: כדי לכבות את MCP, ראה השבתת MCP לחלוטין. כדי לאשר ש-Claude Code קורא את הקובץ, ראה אימות התצורה
• אירועי Hook: Claude Code רושם hook_execution_start ו-hook_execution_complete פעם אחת לכל אירוע hook, ומכסה כל hook תואם. OTEL_LOG_TOOL_DETAILS=1 לבדו לא רושם את כתובת ה-URL של hook מסוג HTTP. תצורת ה-hook מופיעה רק ב-hook_definitions, שגם צריך מעקב בטא מפורט

OTEL_LOG_TOOL_DETAILS=1 מוסיף מחרוזות פקודה, שמות שרת וכלי, וקלט כלי לאירועים האלה. הפירוט הזה יכול להכיל את אותו תוכן רגיש כמו הסשן עצמו, אז הפעל אותו רק כאשר האספן שלך מאושר להחזיק את התוכן הזה.

#בדיקת סריקת השמירה

כדי לתת לכל מכונה את אותה תקופת שמירה, הגדר cleanupPeriodDays בהגדרות מנוהלות. כדי לבדוק שמכונות מריצות את הסריקה עם הערך הזה, אסוף את אירוע retention_sweep. period_days והמונים הם מחרוזות, אז המר אותם למספרים לפני שמשווים אותם.

מכונה שפועלת כמתוכנן יכולה להישאר בלי אירוע מסיבות כמו אלה:

• אף אחד לא מפעיל את Claude Code: לא רצה סריקה, והמכונה שומרת את הנתונים שלה עד ההפעלה הבאה
• סשן נשאר פתוח: Claude Code מריץ את הסריקה לכל היותר פעם אחת בכל סשן
• סשן מסתיים מוקדם: סריקה שלא הסתיימה כשהסשן יוצא לא פולטת כלום, וגם לא סריקה שנעצרת בשגיאה לא צפויה

הסריקה לא מכסה כל נתיב. נשמר עד שאתה מוחק אותם מפרט מה נשאר, וניקוי נתונים מקומיים מראה איך להסיר אותו.

#שליחת אירועים אל SIEM

כוון את OTEL_EXPORTER_OTLP_LOGS_ENDPOINT אל מקלט ה-OTLP של ה-SIEM שלך, או אל OpenTelemetry Collector שמעביר אל API הקליטה המקורי של ה-SIEM שלך. דוגמת ההגדרות המנוהלות הבאה מייצאת אירועים בלבד, עם פירוט כלי מלא מופעל לביקורת של MCP ו-Bash:

{
  "env": {
    "CLAUDE_CODE_ENABLE_TELEMETRY": "1",
    "OTEL_LOGS_EXPORTER": "otlp",
    "OTEL_LOG_TOOL_DETAILS": "1",
    "OTEL_EXPORTER_OTLP_LOGS_PROTOCOL": "http/protobuf",
    "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT": "https://siem.example.com:4318/v1/logs",
    "OTEL_EXPORTER_OTLP_HEADERS": "Authorization=Bearer your-siem-token"
  }
}

כדי לאשר שאירועים מגיעים, שלח prompt בסשן שרץ תחת התצורה הזו ובדוק ב-SIEM שלך את האירוע claude_code.user_prompt. אם שום דבר לא מגיע, התחל את Claude Code עם claude --debug-file <path> ובדוק בלוג הזה שגיאות ייצוא [3P telemetry].

#שיקולי backend

הבחירה שלך ב-backends של מדדים, לוגים ועקבות קובעת את סוגי הניתוחים שאפשר לבצע:

#backends למדדים

• מסדי נתונים של סדרות זמן: חישובי קצב, מדדים מצטברים
• מחסנים עמודתיים: שאילתות מורכבות, ניתוח משתמשים ייחודיים
• פלטפורמות תצפיתיות מלאות: שאילתות מתקדמות, המחשה, התראות

#backends לאירועים וללוגים

• מערכות צבירת לוגים: חיפוש טקסט מלא, ניתוח לוגים
• מחסנים עמודתיים: ניתוח אירועים מובנה
• פלטפורמות תצפיתיות מלאות: מתאם בין מדדים לאירועים

#backends לעקבות

בחר backend שתומך באחסון עקבות מבוזרות ובמתאם spans:

• מערכות מעקב מבוזר: המחשת span, מפלי בקשות, ניתוח השהיה
• פלטפורמות תצפיתיות מלאות: חיפוש עקבות ומתאם עם מדדים ולוגים

לארגונים שדורשים מדדי Daily/Weekly/Monthly Active User (DAU/WAU/MAU), שקול backends שתומכים בשאילתות ערך ייחודי יעילות.

#מידע על השירות

כל המדדים והאירועים מיוצאים עם מאפייני המשאב הבאים:

• service.name: claude-code לסשני מסוף, claude-code-desktop לסשנים מקומיים שהתחילו מלשונית Code באפליקציית Claude Desktop
• service.version: גרסת Claude Code הנוכחית, או גרסת אפליקציית Desktop לסשנים מקומיים בלשונית Code
• os.type: סוג מערכת ההפעלה (למשל, linux, darwin, windows)
• os.version: מחרוזת גרסת מערכת ההפעלה
• host.arch: ארכיטקטורת המארח (למשל, amd64, arm64)
• wsl.version: מספר גרסת WSL (נוכח רק כאשר רצים על Windows Subsystem for Linux)
• שם המונה: com.anthropic.claude_code

אם צינורות האספן או לוחות המחוונים שלך מסננים לפי service.name = claude-code, הוסף claude-code-desktop למסנן כדי ללכוד גם טלמטריה מסשנים מקומיים בלשונית Code.

#משאבי מדידת ROI

למדריך מקיף על מדידת תשואה על ההשקעה עבור Claude Code, כולל הגדרת טלמטריה, ניתוח עלות, מדדי פרודוקטיביות ודיווח אוטומטי, ראה את מדריך מדידת ה-ROI של Claude Code. המאגר הזה מספק תצורות Docker Compose מוכנות לשימוש, הגדרות Prometheus ו-OpenTelemetry, ותבניות ליצירת דוחות פרודוקטיביות שמשולבות עם כלים כמו Linear.

#אבטחה ופרטיות

• ייצוא OpenTelemetry אל ה-backend שלך הוא opt-in ודורש הגדרה מפורשת. לטלמטריה התפעולית הנפרדת של Anthropic ולאופן כיבויה, ראה Data usage
• תוכן קבצים גולמי וקטעי קוד אינם נכללים במדדים או באירועים. טווחי trace הם נתיב נתונים נפרד: ראה את סעיף OTEL_LOG_TOOL_CONTENT למטה
• כשמאמתים באמצעות OAuth, user.email נכלל במאפייני הטלמטריה, ונשלח רק אל נקודת הקצה של OTel שהגדרת, אף פעם לא אל Anthropic. אם זה מדאיג את הארגון שלך, עבוד עם ה-backend של הטלמטריה כדי לסנן או להשחיר את השדה הזה
• תוכן בקשות המשתמש אינו נאסף כברירת מחדל. רק אורך הבקשה נרשם. כדי לכלול את תוכן הבקשה, הגדר OTEL_LOG_USER_PROMPTS=1. כשהאפשרות מופעלת:

  • אירועי user_prompt נושאים את טקסט הבקשה בשני מאפיינים, prompt ו-prompt_text. אם אתה משמיט או ממסך את טקסט הבקשה של האירוע לפי שם מאפיין ב-collector שלך, ציין את שני המאפיינים בכלל

    מעבד ה-attributes הזה של OpenTelemetry Collector מוחק את שני המאפיינים בצינורות שמציינים אותו:

    העתק

    processors:
      attributes/drop-prompt-text:
        actions:
          - key: prompt
            action: delete
          - key: prompt_text
            action: delete

  • כש-tracing מופעל, ה-span של claude_code.interaction נושא את טקסט הבקשה במאפיין user_prompt שלו

  • תחת tracing מפורט בגרסת בטא, spans נושאים גם את הודעות המשתמש החדשות, תוצאות כלים ותזכורות מערכת שנשלחות עם כל בקשה, את טקסט ה-system prompt ואת פלט המודל. Content attributes under detailed beta tracing מפרט כל מאפיין. האירוע claude_code.system_prompt נושא את ה-system prompt המלא

• טקסט תשובת העוזר אינו נאסף כברירת מחדל. רק אורך התשובה נרשם. כדי לכלול את טקסט התשובה, הגדר OTEL_LOG_ASSISTANT_RESPONSES=1. כמו כל נתוני OpenTelemetry מ-Claude Code, טקסט התשובה נשלח רק אל נקודת הקצה של OTel שהגדרת, אף פעם לא אל Anthropic. כשהמשתנה הזה אינו מוגדר, OTEL_LOG_USER_PROMPTS משמש כגיבוי, לכן הגדר OTEL_LOG_ASSISTANT_RESPONSES=0 אם אתה רוצה תוכן בקשות בלי תוכן תשובות באירועים. תחת tracing מפורט בגרסת בטא, ה-span של claude_code.llm_request עדיין נושא פלט מודל ב-response.model_output, שעוקב אחרי OTEL_LOG_USER_PROMPTS ולא אחרי המשתנה הזה
• ארגומנטים ופרמטרים של קלט כלים אינם נרשמים ביומן כברירת מחדל. כדי לכלול אותם, הגדר OTEL_LOG_TOOL_DETAILS=1. עבור השרתים המובנים של Claude Desktop, בסשנים ש-Claude Desktop מחזיק בהם, tool_decision ו-tool_result נושאים את הזוג mcp_server_name/mcp_tool_name, שמות שכתב המארח ולא תוכן ארגומנטים, גם כשהדגל כבוי. הנתונים האלה נשלחים רק אל נקודת הקצה של OTEL שהגדרת, אף פעם לא אל Anthropic. ארגומנטים עדיין עשויים להכיל ערכים רגישים, לכן הגדר את ה-backend של הטלמטריה כך שיסנן או ישחיר את המאפיינים האלה לפי הצורך. כשהאפשרות מופעלת:
  • אירועי tool_result ו-tool_decision כוללים מאפיין tool_parameters עם פקודות Bash, שמות שרת MCP וכלי, ושמות skill. שדות כמו full_command נפלטים בלי קיצור
  • אירועי tool_result כוללים בנוסף מאפיין tool_input עם נתיבי קבצים, כתובות URL, תבניות חיפוש וארגומנטים אחרים. ערכים בודדים מעל 512 תווים מקוצרים, והסך הכולל מוגבל לכ-4 K תווים
  • אירועי user_prompt כוללים את command_name כלשונו עבור פקודות מותאמות אישית, תוספים ו-MCP
  • מוני העלות והאסימונים והאירועים api_request, api_error ו-api_refusal נושאים שמות אמיתיים של agent, skill, תוסף ושרת MCP וכלי במאפייני השיוך שלהם
  • ה-span של claude_code.tool נושא מאפיינים שנגזרו מהקלט, כמו file_path. תחת tracing מפורט בגרסת בטא הוא נושא גם מאפיין tool_input
• תוכן כלים אינו נרשם ביומן בטווחי trace כברירת מחדל. כדי לכלול אותו, הגדר OTEL_LOG_TOOL_CONTENT=1. ה-span של claude_code.tool נושא אז אירוע span של tool.output עם תוכן קבצים גולמי, פלט פקודות Bash, ומה שמחזירים כלי MCP, WebFetch ו-WebSearch, מקוצר במגבלת התוכן (60 KB כברירת מחדל) לכל מאפיין. תוצאות מכלי MCP, WebFetch ו-WebSearch דורשות Claude Code v2.1.283 או מאוחר יותר. תוכן כלים מגיע גם אל spans דרך new_context, שהשער שלו שונה לכל span. הגדר את ה-backend של הטלמטריה כך שיסנן או ישחיר את המאפיינים האלה לפי הצורך
• גופי בקשה ותשובה גולמיים של Anthropic Messages API אינם נרשמים ביומן כברירת מחדל. כדי לכלול אותם, הגדר OTEL_LOG_RAW_API_BODIES ב-shell שלך, בהגדרות המשתמש או בהגדרות מנוהלות. המשתנה מתעלם ממנו ב-הגדרות פרויקט והגדרות מקומיות. הגופים מכילים את היסטוריית השיחה המלאה, כולל ה-system prompt, כל תור קודם של משתמש ועוזר, ותוצאות כלים, ולכן הפעלה של זה מרמזת על הסכמה לכל מה שדגלי התוכן האחרים של OTEL_LOG_* היו חושפים. Claude Code תמיד משחיר את תוכן החשיבה המורחבת של Claude מהגופים האלה, בלי קשר להגדרות אחרות. הערך שאתה מגדיר קובע איך Claude Code מוסר את הגופים:

  • עם =1, Claude Code פולט אירועי יומן api_request_body ו-api_response_body לכל קריאת API. מאפיין ה-body של האירועים נושא את המטען בסידור JSON, מקוצר במגבלת התוכן (60 KB כברירת מחדל)

  • עם =file:<dir>, Claude Code כותב גופים לא מקוצרים לקבצי .request.json ו-.response.json תחת התיקייה הזו, והאירועים נושאים נתיב body_ref במקום הגוף המוטמע. שלח את התיקייה עם אוסף יומנים או sidecar ולא דרך זרם הטלמטריה.

    לכל תשובה מוצלחת, Claude Code גם מוסיף שורה אחת ל-index.jsonl בתיקייה הזו, שמקשרת את קובץ התשובה לקובץ הבקשה שיצר אותו ולהודעת התמליל שהוא הפך אליה. כל שורה אינה מכילה תוכן הודעה, וסעיף אירוע גוף תשובת API מפרט את השדות שלה. קובץ האינדקס דורש Claude Code v2.1.274 או מאוחר יותר

#ניטור Claude Code ב-Amazon Bedrock

להנחיות מפורטות לניטור שימוש ב-Claude Code עבור Amazon Bedrock, ראה Claude Code Monitoring Implementation (Amazon Bedrock).