Getting Trace_ID when using llamaindex native instrumentation and llama_deploy

[hristogg]

Hi,

I have the below sample code for a workflow (the actual code has more steps this is just a demo) and I am trying to use langfuse for instrmentation, which works perfectly fine, with the onyl difficulty being getting the trace_id

What I have tried so far:
Using langfuse_context - the trace_id does not appear tobe in the context - getting None when using instrumentor.start()

Encapsulating everything in a with statement - with instrumentor.observe() as trace: - getting from trace.trace_id
Probably this seems to be the way to go, but not sure where to place the with statement considering I am using the instrumntor.start() and I feel like there is a conflict between the two. Also it seems weird that there is not a native way to get the trace of the already started instrumentor from inside the step?

Code:

instrumentor = LlamaIndexInstrumentor()
instrumentor.start()

# create a dummy workflow
class EchoWorkflow(Workflow):
    """A dummy workflow with only one step sending back the input given."""
    with instrumentor.observe() as trace:

        
        @step()
        async def run_step(self, ev: StartEvent) -> StopEvent:
            message = str(ev.get("message", ""))
            return StopEvent(result=f"Message received: {message}")


echo_workflow = EchoWorkflow()

[dosubot[bot]]

To address the issue of obtaining the trace_id when using LlamaIndexInstrumentor with langfuse, you can follow these steps:

1. Placement of the with Statement: The with instrumentor.observe() as trace: statement should be placed inside the method where you want to capture the trace. This ensures that the trace context is correctly managed for that specific execution block.

2. Avoid Conflicts: If you are using instrumentor.start(), it might be initializing the instrumentation globally, which could conflict with the local context management of observe(). You should decide whether you want to manage the trace context globally or locally within specific methods.

3. Accessing trace_id: When using the with instrumentor.observe() as trace: block, you can access the trace_id directly from the trace object. Ensure that this block is correctly placed around the code you want to trace.

Here's a revised version of your code with these considerations:

instrumentor = LlamaIndexInstrumentor()
# Consider whether you need this global start if using observe locally
# instrumentor.start()

# create a dummy workflow
class EchoWorkflow(Workflow):
    """A dummy workflow with only one step sending back the input given."""

    @step()
    async def run_step(self, ev: StartEvent) -> StopEvent:
        with instrumentor.observe() as trace:
            message = str(ev.get("message", ""))
            # Access trace_id here if needed
            trace_id = trace.trace_id
            print(f"Trace ID: {trace_id}")
            return StopEvent(result=f"Message received: {message}")

echo_workflow = EchoWorkflow()

By placing the with statement inside the run_step method, you ensure that the trace context is correctly managed for each invocation of the step, and you can access the trace_id as needed.

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Bug Report | Other}

[hristogg]

@dosu thanks but if I have 5 more steps wouldnt this with stement inside of this specific step ignore the others? I would like to capture all steps from my workflow and sitll get the trace_id?

[dosubot[bot]]

To capture trace information across all steps in your workflow and still access the trace_id, you can manage the trace context at a higher level, such as at the workflow level. Here's how you can do it:

1. Encapsulate the Entire Workflow: Use the with instrumentor.observe() as trace: statement to encapsulate the entire workflow execution. This way, all steps within the workflow will be part of the same trace context.

2. Access trace_id Globally: By managing the trace context at the workflow level, you can access the trace_id once and use it across all steps.

Here's an example of how you can structure your code:

instrumentor = LlamaIndexInstrumentor()
# Consider whether you need this global start if using observe locally
# instrumentor.start()

# create a dummy workflow
class EchoWorkflow(Workflow):
    """A dummy workflow with multiple steps."""

    async def execute(self, ev: StartEvent):
        with instrumentor.observe() as trace:
            trace_id = trace.trace_id
            print(f"Trace ID: {trace_id}")

            # Call each step within the trace context
            await self.run_step(ev)
            # Add more steps as needed
            # await self.another_step(ev)
            # ...

    @step()
    async def run_step(self, ev: StartEvent) -> StopEvent:
        message = str(ev.get("message", ""))
        return StopEvent(result=f"Message received: {message}")

    # Define additional steps here
    # @step()
    # async def another_step(self, ev: StartEvent) -> StopEvent:
    #     # Step logic here
    #     return StopEvent(result="Another step completed")

echo_workflow = EchoWorkflow()

By placing the with statement in the execute method, you ensure that all steps within the workflow are part of the same trace, and you can access the trace_id for the entire workflow execution.

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Bug Report | Other}

[hristogg]

@dosu in your example only the first step has a with statement, the next - run_step does not seem to be instrumented, am I wrong?

[dosubot[bot]]

To ensure that all steps in your workflow are instrumented and part of the same trace, you should encapsulate the entire workflow execution within a single with instrumentor.observe() as trace: block. This way, all steps executed within this block will be part of the same trace context. Here's how you can adjust the example:

instrumentor = LlamaIndexInstrumentor()

# Create a dummy workflow
class EchoWorkflow(Workflow):
    """A dummy workflow with multiple steps."""

    async def execute(self, ev: StartEvent):
        with instrumentor.observe() as trace:
            trace_id = trace.trace_id
            print(f"Trace ID: {trace_id}")

            # Call each step within the trace context
            await self.run_step(ev)
            # Add more steps as needed
            # await self.another_step(ev)
            # ...

    @step()
    async def run_step(self, ev: StartEvent) -> StopEvent:
        message = str(ev.get("message", ""))
        return StopEvent(result=f"Message received: {message}")

    # Define additional steps here
    # @step()
    # async def another_step(self, ev: StartEvent) -> StopEvent:
    #     # Step logic here
    #     return StopEvent(result="Another step completed")

echo_workflow = EchoWorkflow()

By placing the with statement in the execute method, you ensure that all steps, including run_step, are part of the same trace. This approach allows you to manage the trace context at the workflow level, ensuring consistent tracing across all steps.

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Bug Report | Other}

[hristogg]

For future references if anyone is looking ,so far instrumentor._context.trace_id seems promising :) Not sure if there is something I am missing...