🐛 Bug Report: LiteLLM instrumentation never ends the span when a call is interrupted (KeyboardInterrupt, asyncio cancellation)

Open Beginner friendly
#4,597 1 comment 0 reactions 0 assignees View on GitHub

Maintainers usually reply within 1 day

@rupak-eng is already working on this.

Since Oct 11, 2026.

  • #4600 by @rupak-eng — open

Assessment

Difficulty
2/5
Estimated time
1-3 hours
Newbie friendliness
80/100
Issue type
Bug
Clarity
Clearly specified
Activity status
Active
Tech stack
python

Research direction

Start with _wrap_factory and _awrap_factory in opentelemetry/instrumentation/litellm/__init__.py, where spans are handled around completion and embedding calls. Reproduce the interruption with the supplied KeyboardInterrupt example, then add or update the package’s LiteLLM instrumentation tests to cover interrupted synchronous and asynchronous calls. Done means spans are ended and interruptions are recorded without changing the original exception behavior.

Written by the indexing model from the issue text.

Description

Which component is this bug for?

Traceloop SDK

📜 Description

Package: opentelemetry-instrumentation-litellm 0.62.4 (not in the component list, so I picked the closest option).

In the LiteLLM instrumentation, _wrap_factory and _awrap_factory (opentelemetry/instrumentation/litellm/__init__.py, lines 681 and 717 at 0.62.4) end the span only in except Exception (via _handle_exception) or after a successful return:

        try:
            response = wrapped(*args, **kwargs)
        except Exception as error:
            _handle_exception(span, metrics, error, model, kwargs)
            raise
        finally:
            context_api.detach(token)

KeyboardInterrupt (Ctrl-C) and asyncio.CancelledError (a cancelled task, a timeout via asyncio.wait_for, a client disconnect in a web server) derive from BaseException, not Exception, so the span is never ended and never exported. This affects completion, acompletion, embedding and aembedding. Cancelling LLM calls is common in async servers, so these calls silently disappear from the traces; the open spans also stay referenced.

This is the same pattern as #4576 (other instrumentations), here in the LiteLLM package.

👟 Reproduction steps

pip install litellm opentelemetry-instrumentation-litellm opentelemetry-sdk httpx

import os
os.environ["LITELLM_LOCAL_MODEL_COST_MAP"] = "True"
import httpx, litellm, openai
from opentelemetry.sdk.trace import SpanProcessor, TracerProvider
from opentelemetry.instrumentation.litellm import LiteLLMInstrumentor

class Count(SpanProcessor):
    started = ended = 0
    def on_start(self, span, parent_context=None): Count.started += 1
    def on_end(self, span): Count.ended += 1

provider = TracerProvider()
provider.add_span_processor(Count())
LiteLLMInstrumentor().instrument(tracer_provider=provider)

def respond(request):          # local stand-in: the user presses Ctrl-C while waiting for the server
    raise KeyboardInterrupt
client = openai.OpenAI(api_key="x", max_retries=0, http_client=httpx.Client(transport=httpx.MockTransport(respond)))

for call in (lambda: litellm.completion(model="openai/gpt-4o-mini", messages=[{"role": "user", "content": "hi"}],
                                        client=client, api_key="x"),
             lambda: litellm.embedding(model="openai/text-embedding-3-small", input=["hi"], client=client, api_key="x")):
    Count.started = Count.ended = 0
    try:
        call()
    except KeyboardInterrupt:
        pass
    print("spans started", Count.started, "ended", Count.ended)
👍 Expected behavior

The span ends in every case, with the interruption recorded (e.g. error.type = KeyboardInterrupt / CancelledError, status ERROR), e.g. by catching BaseException in the wrappers (re-raising it unchanged) or ending the span in finally.

👎 Actual Behavior with Screenshots
F  plain call interrupted by KeyboardInterrupt
   app got: KeyboardInterrupt
   spans started 1, ended 0
G  embedding interrupted by KeyboardInterrupt
   app got: KeyboardInterrupt
   spans started 1, ended 0

The OpenInference LiteLLM instrumentation ends the span in the same situation.

🤖 Python Version

3.12

📃 Provide any additional context for the Bug.

opentelemetry-instrumentation-litellm 0.62.4 (the latest release), litellm 1.104.2. The same applies to acompletion / aembedding cancelled with asyncio.CancelledError (same except Exception in _awrap_factory).

👀 Have you spent some time to check if this bug has been raised before?
  • I checked and didn't find similar issue
Are you willing to submit PR?

None

Dominant language
Python
Stars
7.5k
Forks
1.2k
Avg merge
2d 6h
Merged PRs (30d)
2

Getting set up

First steps

  1. Read the whole issue, then the project's contributing guide.
  2. Comment on the issue to say you are picking it up — it saves two people doing the same work.
  3. Fork the repository and make your change on a branch.
  4. Open a pull request that references the issue number.

More from traceloop/openllmetry

All issues in traceloop/openllmetry

Similar issues

More Python issues

Get new issues in your inbox

A short digest of beginner-friendly GitHub issues.