Knowledge check

Test your understanding of Monocle zero-code instrumentation and Okahu for CI/CD pipelines.

---

1. What is the key difference between zero-code and in-code instrumentation?

A. Zero-code only works with LangChain; in-code works with any framework B. Zero-code uses a YAML config and the Monocle CLI with no source code changes; in-code adds setup_monocle_telemetry() directly to the application C. Zero-code produces smaller traces than in-code instrumentation D. They are identical — "zero-code" is just a marketing term

Correct! Zero-code instrumentation reads okahu.yaml and dynamically wraps methods at runtime via python -m monocle_apptrace --config okahu.yaml app.py. The application source code is never modified.

Incorrect. Zero-code instrumentation reads okahu.yaml and dynamically wraps methods at runtime via python -m monocle_apptrace --config okahu.yaml app.py. The application source code is never modified.

2. In okahu.yaml, what does inputs.include: [param1, param2] do?

A. Validates that these parameters are not null before the function runs B. Filters traces to only include calls with these parameter names C. Captures those function parameter values as a data.input event on the span D. Injects default values for those parameters if not provided

Correct! Monocle records the actual argument values as JSON in a data.input span event, making them available for trace analysis and debugging.

Incorrect. Monocle records the actual argument values as JSON in a data.input span event, making them available for trace analysis and debugging.

3. Why does the workflow wait before querying Okahu for traces after a run?

A. To give the GitHub Actions runner time to finish cleanup B. Trace ingestion is asynchronous — the traces need time to be indexed before they are queryable C. To rate-limit API calls to the Okahu platform D. To wait for the Kahu SRE Agent to become available

Correct! Traces are sent to Okahu's ingestion endpoint during the run, but they need a few seconds to be processed and indexed before the API can return them in queries.

Incorrect. Traces are sent to Okahu's ingestion endpoint during the run, but they need a few seconds to be processed and indexed before the API can return them in queries.

4. How does the Okahu API identify which traces belong to a specific CI/CD run?

A. Monocle tags traces with scope.git.run.id = github_{GITHUB_RUN_ID}, and the API filters by that scope fact B. It matches traces by the exact timestamp of the workflow run C. Each workflow run creates a unique Okahu application D. It downloads all traces and filters them locally with jq

Correct! Scope-based fact lookup lets you query ?duration_fact=test_runs&fact_ids=github_{RUN_ID} to get only the traces tagged with that specific run ID.

Incorrect. Scope-based fact lookup lets you query ?duration_fact=test_runs&fact_ids=github_{RUN_ID} to get only the traces tagged with that specific run ID.

5. What does Monocle capture in data.output when an instrumented method raises an exception before returning?

A. None, because the method never returned a value B. The full stack trace of the exception C. A JSON error object with the exception message D. The output is not captured at all for failed spans

Correct! Since the method raised an exception before returning, Monocle captures None as the output. The Kahu SRE Agent sees None output combined with a failed span status and uses this to diagnose the issue.

Incorrect. Since the method raised an exception before returning, Monocle captures None as the output. The Kahu SRE Agent sees None output combined with a failed span status and uses this to diagnose the issue.

6. Can you combine zero-code YAML instrumentation with in-code setup_monocle_telemetry in the same application?

A. No — they conflict and would produce duplicate traces B. No — you must choose one approach per application C. Yes — YAML instruments custom functions while setup_monocle_telemetry handles framework auto-instrumentation, both in the same trace D. Yes, but only if you use the console exporter

Correct! Both approaches produce spans in the same trace. This is useful when part of your application uses a supported framework (LangChain, ADK) and part is custom code.

Incorrect. Both approaches produce spans in the same trace. This is useful when part of your application uses a supported framework (LangChain, ADK) and part is custom code.

7. How does the Kahu SRE Agent use Monocle trace data to perform root cause analysis?

A. It only reads the workflow log output from GitHub Actions B. It compares the current trace against a baseline of known-good traces C. It analyzes span names, statuses, data.input, and data.output events to identify what failed and why D. It re-runs the failed steps and compares the results

Correct! The Kahu SRE Agent queries traces from Okahu and examines each span's metadata — including captured inputs, outputs, status, and duration — to produce a structured root cause analysis.

Incorrect. The Kahu SRE Agent queries traces from Okahu and examines each span's metadata — including captured inputs, outputs, status, and duration — to produce a structured root cause analysis.