continuous-intelligence-layer 0.1.0__py3-none-any.whl

continuous_intelligence_layer/crewai/init.py

@@ -0,0 +1,228 @@
+"""
+init.py
+-------
+The public entry point for CrewAI agents.
+
+    from continuous_intelligence_layer.crewai import init
+    init()
+
+That's all the user needs to write. Everything else is automatic.
+
+How it works (internals)
+------------------------
+1.  We create an ExecutionSpanExporter — our custom JSONL writer.
+2.  We build an OpenTelemetry TracerProvider and attach the exporter via a
+    SimpleSpanProcessor.  SimpleSpanProcessor calls exporter.export() *synchronously*
+    on every span that finishes, so nothing is lost even if the process exits abruptly.
+3.  We set this provider as the GLOBAL OTel provider for the Python process.
+    Any library that uses `opentelemetry.trace.get_tracer(...)` will now use it.
+4.  We call instrument(provider) which activates the OpenInference
+    CrewAIInstrumentor (see instrumentation.py). This monkey-patches CrewAI's
+    internals to emit OTel spans for every crew kickoff, agent task, LLM
+    call, tool call, etc. — completely automatically.
+5.  When the user's agent runs, spans flow:
+        CrewAI  →  OpenInference patch  →  OTel SDK  →  SimpleSpanProcessor
+        →  ExecutionSpanExporter.export()  →  JSONL file on disk
+"""
+
+from __future__ import annotations
+
+import uuid
+import requests
+
+from opentelemetry import trace
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+
+from .._core.exporter import ExecutionSpanExporter
+from .instrumentation import instrument
+
+# Guard against double-init in the same process
+_INITIALIZED: bool = False
+_PROVIDER: TracerProvider | None = None
+
+
+def init(
+    api_key: str,
+    output_path: str = "./execution_trace.jsonl",
+    service_name: str = "continuous-intelligence-layer",
+    execution_id: str | None = None,
+    session_id: str | None = None,
+    store: str | None = "mongodb",
+    write_jsonl: bool = False,
+    verbose: bool = True,
+    base_url: str = "http://localhost:8080",
+    run_evaluations: bool = True,
+    evaluation_api_key: str = "",
+    evaluation_provider: str = "openai",
+    evaluation_model: str = "gpt-5.6-luna",
+) -> dict:
+    """
+    Initialize the Continuous Intelligence Layer SDK for CrewAI.
+
+    Call this ONCE, at the very top of your script, before creating or running
+    any Crew.  No other changes to your agent code are required.
+
+    Parameters
+    ----------
+    output_path :
+        Path to the JSONL file where spans will be appended, if
+        ``write_jsonl=True``. File is created automatically; parent dirs are
+        created if needed. Each call to init() with a new execution_id
+        appends to the same file, so you can accumulate traces from multiple
+        runs.
+    write_jsonl :
+        If True, also append every span to a local JSONL file at
+        ``output_path``. Defaults to False when ``store="mongodb"`` — MongoDB
+        is the single source of truth by default, and JSONL is only an
+        opt-in local debug/backup mechanism. Automatically forced on when
+        ``store`` is not "mongodb" (otherwise nothing would be persisted).
+    service_name :
+        An arbitrary label written to every span as ``service.name``.
+        Useful when you have multiple agents writing to the same file.
+    execution_id :
+        A short identifier for *this* pipeline run.  Auto-generated (12-char
+        UUID fragment) if not provided.  Stored on every span as
+        ``execution_id``, so you can filter a single run later.
+    session_id :
+        Identifier for the conversational session/thread.
+    store :
+        Optional. If set to "mongodb", also buffers spans and saves them to
+        MongoDB on shutdown.
+    verbose :
+        Print a one-line confirmation when init succeeds.
+    run_evaluations :
+        If True (the default), evaluations and RCA run automatically on the
+        backend right after the trace finishes ingesting — no need to call
+        the ``run-evaluations`` endpoint or click "Run Evaluation" in the UI
+        separately. Pass False to keep today's behavior: evaluations only
+        run when triggered manually.
+
+    Returns
+    -------
+    dict
+        ``{"execution_id": str, "output_path": str}``
+        Keep a reference if you need to correlate spans to a run ID later.
+
+    Notes
+    -----
+    Calling init() a second time in the same process is a no-op — the existing
+    provider is reused.  If you genuinely need a fresh provider (e.g., in
+    tests), call ``reset()`` first.
+    """
+    global _INITIALIZED, _PROVIDER
+
+    if _INITIALIZED:
+        if verbose:
+            print(
+                f"[continuous-intelligence-layer] ⚠  Already initialized — skipping. "
+                f"Call reset() first if you need a fresh provider."
+            )
+        return {"execution_id": execution_id or "unknown", "output_path": output_path}
+
+    execution_id = execution_id or str(uuid.uuid4())[:12]
+    session_id = session_id or str(uuid.uuid4())[:12]
+
+    # ── Step 1: Build the span exporter ─────────────────────────────────────
+    write_jsonl = write_jsonl or store != "mongodb"
+    exporter = ExecutionSpanExporter(
+        output_path=output_path,
+        execution_id=execution_id,
+        session_id=session_id,
+    )
+
+    # ── Step 2: Sync Project & Build TracerProvider ────────────────────────
+    if not api_key:
+        raise ValueError("API Key is not provided. An API Key is required to initialize the SDK.")
+
+    if not evaluation_api_key:
+        raise ValueError(
+            "evaluation_api_key is not provided. An LLM API key (OpenAI, Anthropic, "
+            "or Gemini) is required to initialize the SDK -- it's used to run "
+            "evaluations and RCA on your traces. We never use our own key for your work."
+        )
+
+    try:
+        res = requests.post(
+            f"{base_url}/projects/sync",
+            json={
+                "name": service_name,
+                "execution_id": execution_id,
+                "evaluation_provider": evaluation_provider,
+                "evaluation_model": evaluation_model,
+                "evaluation_api_key": evaluation_api_key,
+            },
+            headers={"x-api-key": api_key}
+        )
+        if res.status_code == 401:
+            raise ValueError("API Key is not valid.")
+        res.raise_for_status()
+        project_id = res.json()["id"]
+    except requests.exceptions.RequestException as e:
+        raise ValueError(f"Failed to verify API key with backend: {e}")
+
+    resource_attrs = {
+        "service.name": service_name,
+        "project.id": project_id,
+        "execution.id": execution_id,
+        "sdk.name":     "continuous-intelligence-layer",
+        "sdk.version":  "0.1.0",
+    }
+    if session_id:
+        resource_attrs["session.id"] = session_id
+
+    resource = Resource.create(resource_attrs)
+    provider = TracerProvider(resource=resource)
+
+    # ── Step 3: Attach SimpleSpanProcessor ────────────────────────────────
+    if write_jsonl:
+        provider.add_span_processor(SimpleSpanProcessor(exporter))
+
+    if store == "mongodb":
+        from .._core.graph_exporter import GraphSpanExporter
+        graph_exporter = GraphSpanExporter(
+            exporter,
+            session_id=session_id,
+            base_url=base_url,
+            api_key=api_key,
+            project_id=project_id,
+            run_evaluations=run_evaluations,
+        )
+        provider.add_span_processor(SimpleSpanProcessor(graph_exporter))
+
+    # ── Step 4: Set as global OTel provider ───────────────────────────────
+    trace.set_tracer_provider(provider)
+    _PROVIDER = provider
+
+    # ── Step 5: Auto-instrument CrewAI ─────────────────────────────────────
+    instrument(provider)
+
+    _INITIALIZED = True
+
+    if verbose:
+        store_line = f"  Store         : MongoDB (project={service_name})\n" if store == "mongodb" else ""
+        jsonl_line = f"  Output file   : {output_path}\n" if write_jsonl else ""
+        print(
+            f"[continuous-intelligence-layer] ✅ Initialized\n"
+            f"  Execution ID  : {execution_id}\n"
+            f"{store_line}"
+            f"{jsonl_line}"
+            f"  Service name  : {service_name}"
+        )
+
+    return {"execution_id": execution_id, "output_path": output_path}
+
+
+def reset() -> None:
+    """
+    Reset the SDK so init() can be called again.
+
+    Primarily useful in test suites where each test needs a fresh provider.
+    Calling this in production code is rarely needed.
+    """
+    global _INITIALIZED, _PROVIDER
+    from .instrumentation import uninstrument
+    uninstrument()
+    _INITIALIZED = False
+    _PROVIDER = None

continuous_intelligence_layer/crewai/instrumentation.py

@@ -0,0 +1,83 @@
+"""
+instrumentation.py
+------------------
+Activates OpenInference auto-instrumentation for CrewAI agents.
+
+How OpenInference works internally
+------------------------------------
+The instrumentor hooks into CrewAI's own event bus and emits OTel spans using
+the vendor-neutral semantic-convention attribute names (openinference.span.kind,
+input.value, llm.model_name, tool.name, etc. — see
+`continuous_intelligence_layer/_core/exporter.py`). Because every OpenInference
+instrumentor speaks that shared vocabulary, the rest of the SDK (`_core/`,
+`graph_builder/`, `evaluators/`, `rca_engine/`) doesn't need to know which
+framework produced a given span.
+
+use_event_listener=True (not the package default)
+---------------------------------------------------
+`openinference-instrumentation-crewai`'s DEFAULT mode ("legacy wrapper") only
+wraps `Task._execute_core`/`Crew.kickoff`/`Flow.*`/tool `.run()`/memory
+`.save()`/`.search()` — it never wraps the actual LLM call, so no LLM-kind
+span (and therefore no captured prompt) is ever produced for CrewAI agents
+under that mode. The event-listener mode additionally emits a real
+`"<model>.llm_call"` LLM span per model call, and — critically — the
+Agent-execution span itself gets `input.value` populated directly from the
+resolved `task_prompt`/`task_description` (see
+`openinference/instrumentation/crewai/_event_listener.py::_build_agent_start_spec`),
+instead of only carrying static agent config. This is required for
+`evaluators/crewai_input_evaluator.py` and `evaluators/tool_agent_evaluator.py`
+(whose docstring already assumes per-iteration CrewAI LLM spans exist) to see
+real content.
+"""
+
+from __future__ import annotations
+
+from opentelemetry.sdk.trace import TracerProvider
+
+_instrumentor = None
+
+
+def instrument(provider: TracerProvider) -> None:
+    """
+    Activate CrewAI OpenInference auto-instrumentation.
+
+    Parameters
+    ----------
+    provider :
+        The TracerProvider to attach spans to. Must be the same provider that
+        was set as the global OTel provider.
+    """
+    global _instrumentor
+    if _instrumentor is not None:
+        # Already instrumented — avoid double-patching
+        return
+
+    try:
+        from openinference.instrumentation.crewai import CrewAIInstrumentor
+    except ImportError:
+        print(
+            "[continuous-intelligence-layer] ⚠️  openinference-instrumentation-crewai not found.\n"
+            "  crewai spans will NOT be captured automatically.\n"
+            "  Fix: pip install openinference-instrumentation-crewai"
+        )
+        return
+
+    try:
+        instrumentor = CrewAIInstrumentor()
+        instrumentor.instrument(tracer_provider=provider, use_event_listener=True)
+        _instrumentor = instrumentor
+        print("[continuous-intelligence-layer] 🔌 crewai auto-instrumentation active.")
+    except Exception as exc:
+        print(f"[continuous-intelligence-layer] ⚠️  Instrumentation of 'crewai' failed: {exc}")
+
+
+def uninstrument() -> None:
+    """Remove CrewAI OpenInference instrumentation."""
+    global _instrumentor
+    if _instrumentor is None:
+        return
+    try:
+        _instrumentor.uninstrument()
+    except Exception:
+        pass
+    _instrumentor = None

continuous_intelligence_layer/langgraph/__init__.py

@@ -0,0 +1,12 @@
+"""LangGraph/LangChain integration for continuous_intelligence_layer.
+
+Also covers plain LangChain usage — both map to the same OpenInference
+LangChainInstrumentor, so there is no separate `langchain` folder.
+
+    from continuous_intelligence_layer.langgraph import init
+    init(api_key=...)
+"""
+from .init import init, reset
+from .._core.utils import load_traces, print_trace_summary
+
+__all__ = ["init", "reset", "load_traces", "print_trace_summary"]

continuous_intelligence_layer/langgraph/init.py

@@ -0,0 +1,253 @@
+"""
+init.py
+-------
+The public entry point for LangGraph/LangChain agents.
+
+    from continuous_intelligence_layer.langgraph import init
+    init()
+
+That's all the user needs to write. Everything else is automatic.
+
+How it works (internals)
+------------------------
+1.  We create an ExecutionSpanExporter — our custom JSONL writer.
+2.  We build an OpenTelemetry TracerProvider and attach the exporter via a
+    SimpleSpanProcessor.  SimpleSpanProcessor calls exporter.export() *synchronously*
+    on every span that finishes, so nothing is lost even if the process exits abruptly.
+3.  We set this provider as the GLOBAL OTel provider for the Python process.
+    Any library that uses `opentelemetry.trace.get_tracer(...)` will now use it.
+4.  We call instrument(provider) which activates the OpenInference
+    LangChainInstrumentor (covers both LangGraph and plain LangChain — see
+    instrumentation.py). This monkey-patches LangChain's internals to emit
+    OTel spans for every node, LLM call, tool call, retriever call, etc. —
+    completely automatically.
+5.  When the user's agent runs, spans flow:
+        LangGraph/LangChain  →  OpenInference patch  →  OTel SDK  →  SimpleSpanProcessor
+        →  ExecutionSpanExporter.export()  →  JSONL file on disk
+"""
+
+from __future__ import annotations
+
+import uuid
+import requests
+
+from opentelemetry import trace
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+
+from .._core.exporter import ExecutionSpanExporter
+from .instrumentation import instrument
+
+# Guard against double-init in the same process
+_INITIALIZED: bool = False
+_PROVIDER: TracerProvider | None = None
+
+
+def init(
+    api_key: str,
+    output_path: str = "./execution_trace.jsonl",
+    service_name: str = "continuous-intelligence-layer",
+    execution_id: str | None = None,
+    session_id: str | None = None,
+    store: str | None = "mongodb",
+    write_jsonl: bool = False,
+    verbose: bool = True,
+    base_url: str = "http://localhost:8080",
+    run_evaluations: bool = True,
+    evaluation_api_key: str = "",
+    evaluation_provider: str = "openai",
+    evaluation_model: str = "gpt-5.6-luna",
+) -> dict:
+    """
+    Initialize the Continuous Intelligence Layer SDK for LangGraph/LangChain.
+
+    Call this ONCE, at the very top of your script, before creating or running
+    any LangGraph graph.  No other changes to your agent code are required.
+
+    Parameters
+    ----------
+    output_path :
+        Path to the JSONL file where spans will be appended, if
+        ``write_jsonl=True``. File is created automatically; parent dirs are
+        created if needed. Each call to init() with a new execution_id
+        appends to the same file, so you can accumulate traces from multiple
+        runs.
+    write_jsonl :
+        If True, also append every span to a local JSONL file at
+        ``output_path``. Defaults to False when ``store="mongodb"`` — MongoDB
+        is the single source of truth by default, and JSONL is only an
+        opt-in local debug/backup mechanism. Automatically forced on when
+        ``store`` is not "mongodb" (otherwise nothing would be persisted).
+    service_name :
+        An arbitrary label written to every span as ``service.name``.
+        Useful when you have multiple agents writing to the same file.
+    execution_id :
+        A short identifier for *this* pipeline run.  Auto-generated (12-char
+        UUID fragment) if not provided.  Stored on every span as
+        ``execution_id``, so you can filter a single run later.
+    session_id :
+        Identifier for the conversational session/thread.
+    store :
+        Optional. If set to "mongodb", also buffers spans and saves them to
+        MongoDB on shutdown.
+    verbose :
+        Print a one-line confirmation when init succeeds.
+    run_evaluations :
+        If True (the default), evaluations and RCA run automatically on the
+        backend right after the trace finishes ingesting — no need to call
+        the ``run-evaluations`` endpoint or click "Run Evaluation" in the UI
+        separately. Pass False to keep today's behavior: evaluations only
+        run when triggered manually.
+
+    Returns
+    -------
+    dict
+        ``{"execution_id": str, "output_path": str}``
+        Keep a reference if you need to correlate spans to a run ID later.
+
+    Notes
+    -----
+    Calling init() a second time in the same process is a no-op — the existing
+    provider is reused.  If you genuinely need a fresh provider (e.g., in
+    tests), call ``reset()`` first.
+    """
+    global _INITIALIZED, _PROVIDER
+
+    if _INITIALIZED:
+        if verbose:
+            print(
+                f"[continuous-intelligence-layer] ⚠  Already initialized — skipping. "
+                f"Call reset() first if you need a fresh provider."
+            )
+        return {"execution_id": execution_id or "unknown", "output_path": output_path}
+
+    execution_id = execution_id or str(uuid.uuid4())[:12]
+    session_id = session_id or str(uuid.uuid4())[:12]
+
+    # ── Step 1: Build the span exporter ─────────────────────────────────────
+    #
+    # ExecutionSpanExporter is a standard OTel SpanExporter that knows how to
+    # parse a ReadableSpan into a flat dict (via ._extract). GraphSpanExporter
+    # reuses that parsing logic to build the MongoDB graph, so this object is
+    # always constructed — but it's only wired up to actually *write* a JSONL
+    # file to disk if write_jsonl is True. When store="mongodb", MongoDB is
+    # the single source of truth by default; when store is not "mongodb"
+    # there'd be nowhere else for spans to go, so JSONL is forced on.
+    #
+    write_jsonl = write_jsonl or store != "mongodb"
+    exporter = ExecutionSpanExporter(
+        output_path=output_path,
+        execution_id=execution_id,
+        session_id=session_id,
+    )
+
+    # ── Step 2: Sync Project & Build TracerProvider ────────────────────────
+    if not api_key:
+        raise ValueError("API Key is not provided. An API Key is required to initialize the SDK.")
+
+    if not evaluation_api_key:
+        raise ValueError(
+            "evaluation_api_key is not provided. An LLM API key (OpenAI, Anthropic, "
+            "or Gemini) is required to initialize the SDK -- it's used to run "
+            "evaluations and RCA on your traces. We never use our own key for your work."
+        )
+
+    try:
+        res = requests.post(
+            f"{base_url}/projects/sync",
+            json={
+                "name": service_name,
+                "execution_id": execution_id,
+                "evaluation_provider": evaluation_provider,
+                "evaluation_model": evaluation_model,
+                "evaluation_api_key": evaluation_api_key,
+            },
+            headers={"x-api-key": api_key}
+        )
+        if res.status_code == 401:
+            raise ValueError("API Key is not valid.")
+        res.raise_for_status()
+        project_id = res.json()["id"]
+    except requests.exceptions.RequestException as e:
+        raise ValueError(f"Failed to verify API key with backend: {e}")
+
+    resource_attrs = {
+        "service.name": service_name,
+        "project.id": project_id,
+        "execution.id": execution_id,
+        "sdk.name":     "continuous-intelligence-layer",
+        "sdk.version":  "0.1.0",
+    }
+    if session_id:
+        resource_attrs["session.id"] = session_id
+
+    resource = Resource.create(resource_attrs)
+    provider = TracerProvider(resource=resource)
+
+    # ── Step 3: Attach SimpleSpanProcessor ────────────────────────────────
+    #
+    # SimpleSpanProcessor calls exporter.export([span]) synchronously on every
+    # span.end().  This guarantees no spans are lost even if the process crashes.
+    # (For high-throughput production use, replace with BatchSpanProcessor.)
+    #
+    if write_jsonl:
+        provider.add_span_processor(SimpleSpanProcessor(exporter))
+
+    if store == "mongodb":
+        from .._core.graph_exporter import GraphSpanExporter
+        graph_exporter = GraphSpanExporter(
+            exporter,
+            session_id=session_id,
+            base_url=base_url,
+            api_key=api_key,
+            project_id=project_id,
+            run_evaluations=run_evaluations,
+        )
+        provider.add_span_processor(SimpleSpanProcessor(graph_exporter))
+
+    # ── Step 4: Set as global OTel provider ───────────────────────────────
+    #
+    # Any library that calls opentelemetry.trace.get_tracer() anywhere in the
+    # process will now route spans through our provider.
+    #
+    trace.set_tracer_provider(provider)
+    _PROVIDER = provider
+
+    # ── Step 5: Auto-instrument LangGraph/LangChain ────────────────────────
+    #
+    # The OpenInference LangChainInstrumentor monkey-patches LangChain's own
+    # callback/hook system. After this call, LLM calls, agent/tool
+    # invocations, and retriever calls are intercepted and an OTel span is
+    # emitted. The user's agent code never needs to know this is happening.
+    #
+    instrument(provider)
+
+    _INITIALIZED = True
+
+    if verbose:
+        store_line = f"  Store         : MongoDB (project={service_name})\n" if store == "mongodb" else ""
+        jsonl_line = f"  Output file   : {output_path}\n" if write_jsonl else ""
+        print(
+            f"[continuous-intelligence-layer] ✅ Initialized\n"
+            f"  Execution ID  : {execution_id}\n"
+            f"{store_line}"
+            f"{jsonl_line}"
+            f"  Service name  : {service_name}"
+        )
+
+    return {"execution_id": execution_id, "output_path": output_path}
+
+
+def reset() -> None:
+    """
+    Reset the SDK so init() can be called again.
+
+    Primarily useful in test suites where each test needs a fresh provider.
+    Calling this in production code is rarely needed.
+    """
+    global _INITIALIZED, _PROVIDER
+    from .instrumentation import uninstrument
+    uninstrument()
+    _INITIALIZED = False
+    _PROVIDER = None

continuous_intelligence_layer/langgraph/instrumentation.py

@@ -0,0 +1,71 @@
+"""
+instrumentation.py
+------------------
+Activates OpenInference auto-instrumentation for LangGraph/LangChain agents.
+
+Both LangGraph and plain LangChain map to the same
+`openinference.instrumentation.langchain.LangChainInstrumentor` — there is no
+separate instrumentor class for LangGraph, so this single folder covers both.
+
+How OpenInference works internally
+------------------------------------
+The instrumentor hooks into LangChain's own callback-handler system and emits
+OTel spans using the vendor-neutral semantic-convention attribute names
+(openinference.span.kind, input.value, llm.model_name, tool.name, etc. — see
+`continuous_intelligence_layer/_core/exporter.py`). Because every OpenInference
+instrumentor speaks that shared vocabulary, the rest of the SDK (`_core/`,
+`graph_builder/`, `evaluators/`, `rca_engine/`) doesn't need to know which
+framework produced a given span.
+"""
+
+from __future__ import annotations
+
+from opentelemetry.sdk.trace import TracerProvider
+
+_instrumentor = None
+
+
+def instrument(provider: TracerProvider) -> None:
+    """
+    Activate LangChain/LangGraph OpenInference auto-instrumentation.
+
+    Parameters
+    ----------
+    provider :
+        The TracerProvider to attach spans to. Must be the same provider that
+        was set as the global OTel provider.
+    """
+    global _instrumentor
+    if _instrumentor is not None:
+        # Already instrumented — avoid double-patching
+        return
+
+    try:
+        from openinference.instrumentation.langchain import LangChainInstrumentor
+    except ImportError:
+        print(
+            "[continuous-intelligence-layer] ⚠️  openinference-instrumentation-langchain not found.\n"
+            "  langgraph/langchain spans will NOT be captured automatically.\n"
+            "  Fix: pip install openinference-instrumentation-langchain"
+        )
+        return
+
+    try:
+        instrumentor = LangChainInstrumentor()
+        instrumentor.instrument(tracer_provider=provider)
+        _instrumentor = instrumentor
+        print("[continuous-intelligence-layer] 🔌 langgraph auto-instrumentation active.")
+    except Exception as exc:
+        print(f"[continuous-intelligence-layer] ⚠️  Instrumentation of 'langgraph' failed: {exc}")
+
+
+def uninstrument() -> None:
+    """Remove LangChain/LangGraph OpenInference instrumentation."""
+    global _instrumentor
+    if _instrumentor is None:
+        return
+    try:
+        _instrumentor.uninstrument()
+    except Exception:
+        pass
+    _instrumentor = None

continuous_intelligence_layer/openai/__init__.py

@@ -0,0 +1,9 @@
+"""Direct OpenAI SDK integration for continuous_intelligence_layer.
+
+    from continuous_intelligence_layer.openai import init
+    init(api_key=...)
+"""
+from .init import init, reset
+from .._core.utils import load_traces, print_trace_summary
+
+__all__ = ["init", "reset", "load_traces", "print_trace_summary"]