fix(llmobs): remove base URL checks for LLM Obs integrations (#13580)

This PR reverts the changes from #12457 since we have received many
escalations due to customers not seeing their spans appear in LLM
Observability when using a non-default base URL. I decided to do this
revert manually to avoid confusing conflicts with more recent changes to
the integrations.

I am opting to do manual testing for this change since functionality
should return to what it was before #12457, and I have a PR in progress
to implement the remaining portion of this work (allow users to
configure their proxy URLs in order to get workflow spans instead of LLM
spans for client-side requests directed to a proxy) which will include
tests for proxy requests.

# Manual Testing

## Anthropic
Request with default base URL
([trace](https://dd.datad0g.com/llm/traces?query=%40ml_app%3Anicole-test%20%40event_type%3Aspan%20%40parent_id%3Aundefined&agg_m=count&agg_m_source=base&agg_t=count&fromUser=false&llmPanels=%5B%7B%22t%22%3A%22sampleDetailPanel%22%2C%22rEID%22%3A%22AwAAAZc7PN0I94T_HgAAABhBWmM3UE4wSUFBRGMxX2RJZ000VUFBQUEAAAAkZjE5NzNiM2MtZjYwMC00Y2Y5LTg2YjEtMWEyOWNiZDdmNjM4AAAJ8w%22%7D%5D&sidepanelTab=trace&spanId=5618139561267282384&start=1749041976715&end=1749045576715&paused=false)).
```
from anthropic import Anthropic

client = Anthropic()

message = client.messages.create(
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "What color is the sky?",
        }
    ],
    model="claude-3-5-sonnet-20240620",
)
```
Request with base URL specified
([trace](https://dd.datad0g.com/llm/traces?query=%40ml_app%3Anicole-test%20%40event_type%3Aspan%20%40parent_id%3Aundefined&agg_m=count&agg_m_source=base&agg_t=count&fromUser=true&llmPanels=%5B%7B%22t%22%3A%22sampleDetailPanel%22%2C%22rEID%22%3A%22AwAAAZc7PgZl-CD_HgAAABhBWmM3UGdabEFBQkFWYk9mSVVnZEFBQUEAAAAkMDE5NzNiM2UtMGE0OS00ZDljLWJjZGQtNzBkMDM1MWZlYTVhAAAJhQ%22%7D%5D&sidepanelTab=trace&spanId=12859714686052428327&start=1749044723711&end=1749045623711&paused=false)).
```
from anthropic import Anthropic

client = Anthropic(
    base_url="http://localhost:4000",
)

message = client.messages.create(
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "What color is the sky?",
        }
    ],
    model="claude-3.5",
)
```

## Bedrock

Request with default base URL
([trace](https://dd.datad0g.com/llm/traces?query=%40ml_app%3Anicole-test%20%40event_type%3Aspan%20%40parent_id%3Aundefined&agg_m=count&agg_m_source=base&agg_t=count&fromUser=true&llmPanels=%5B%7B%22t%22%3A%22sampleDetailPanel%22%2C%22rEID%22%3A%22AwAAAZc7P8PE-Sn_HgAAABhBWmM3UDhQRUFBREV6NUdlUnc5QUFBQUEAAAAkZjE5NzNiNDAtMDc5Yi00NTJkLTgwNTYtNmY0NDk0YmYwMWUyAAAJiw%22%7D%5D&sidepanelTab=trace&spanId=9734361671629963740&start=1749044925806&end=1749045825806&paused=false)).
```
import boto3
import json

session = boto3.Session(profile_name='601427279990_account-admin', region_name="us-east-1")
brt = session.client(
    service_name='bedrock-runtime', 
)
modelId = 'amazon.titan-text-lite-v1'
accept = 'application/json'
contentType = 'application/json'
input_text = "Explain black holes to 8th graders."
body = {
    "inputText": input_text,
}
body = json.dumps(body)
response = brt.invoke_model(body=body, modelId=modelId, accept=accept, contentType=contentType)
response_body = json.loads(response.get('body').read())
```

Request with base URL specified (traces for when server is
[instrumented](https://dd.datad0g.com/llm/traces?query=%40ml_app%3Anicole-test%20%40event_type%3Aspan%20%40parent_id%3Aundefined&agg_m=count&agg_m_source=base&agg_t=count&fromUser=false&llmPanels=%5B%7B%22t%22%3A%22sampleDetailPanel%22%2C%22rEID%22%3A%22AwAAAZc7QSom-fb_HgAAABhBWmM3UVNvbUFBRGpSV3ZJbVJfbkFBQUEAAAAkMDE5NzNiNDEtNDU3Yy00OWI5LWI1ZWItZjg5YmMyYWEyM2QyAAAI7w%22%7D%5D&sidepanelTab=trace&spanId=5082411573978329245&start=1749044950932&end=1749045850932&paused=false)
and not
[instrumented](https://dd.datad0g.com/llm/traces?query=%40ml_app%3Anicole-test%20%40event_type%3Aspan%20%40parent_id%3Aundefined&agg_m=count&agg_m_source=base&agg_t=count&fromUser=true&llmPanels=%5B%7B%22t%22%3A%22sampleDetailPanel%22%2C%22rEID%22%3A%22AwAAAZc7QtYB2Z5mCAAAABhBWmM3UXRZQkFBQ3JxZkVMa2oxQUFBQUEAAABdMTE5NzNiNDMtMGE1Yi00ZmQzLTlhM2MtYTI1YzE2NzgwNmI1LXN5bnRoZXRpYy10aW1lLTE3NDkwNDIwMDAwMDAwMDAwMDBjLTE3NDkwNDU5Mzg3NzkwMDAwMDFvAAAJ2Q%22%7D%5D&sidepanelTab=trace&spanId=8610037816587948263&start=1749045049165&end=1749045949165&paused=false)).
Server Code (I created a proxy server of my own to test this out!)
```
from fastapi import FastAPI, Request
import uvicorn
import boto3
import json

app = FastAPI()

@app.post("/model/{model_id}/invoke")
async def invoke_model(model_id: str, request: Request):
    body = await request.json()

    session = boto3.Session(profile_name='601427279990_account-admin', region_name="us-east-1")
    brt = session.client(
        service_name='bedrock-runtime', 
    )
    
    body = json.dumps(body)
    response = brt.invoke_model(body=body, modelId=request.path_params.get("model_id"), accept=request.headers.get("accept"), contentType=request.headers.get("content-type"))
    response_body = json.loads(response.get('body').read())
    
    return response_body

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=4000) 
```
Client code
```
import boto3
import json

session = boto3.Session(profile_name='601427279990_account-admin', region_name="us-east-1")
brt = session.client(
    service_name='bedrock-runtime', 
    endpoint_url="http://0.0.0.0:4000",
)
modelId = 'amazon.titan-text-lite-v1'
accept = 'application/json'
contentType = 'application/json'
input_text = "Explain black holes to 8th graders."
body = {
    "inputText": input_text,
}
body = json.dumps(body)
response = brt.invoke_model(body=body, modelId=modelId, accept=accept, contentType=contentType)
response_body = json.loads(response.get('body').read())
```

## Langchain
Request with default base URL
([trace](https://dd.datad0g.com/llm/traces?query=%40ml_app%3Anicole-test%20%40event_type%3Aspan%20%40parent_id%3Aundefined&agg_m=count&agg_m_source=base&agg_t=count&fromUser=true&llmPanels=%5B%7B%22t%22%3A%22sampleDetailPanel%22%2C%22rEID%22%3A%22AwAAAZc7Th6v-LXdEgAAABhBWmM3VGg2dkFBQmRpN05Hb29rM0FBQUEAAABdMTE5NzNiNGUtMzA2Ni00YmMwLWIzZWQtZDcxNWZhNzc4NTI3LXN5bnRoZXRpYy10aW1lLTE3NDkwNDU2MDAwMDAwMDAwMDBjLTE3NDkwNDY2Njk0MTQwMDAwMDFvAAAAJA%22%7D%5D&sidepanelTab=trace&spanId=10904991825240620648&start=1749045791545&end=1749046691545&paused=false)).
```
from langchain.chat_models import ChatOpenAI
from langchain.schema import HumanMessage, SystemMessage

chat = ChatOpenAI(
    model = "gpt-3.5-turbo",
    temperature=0.1,
)

messages = [
    SystemMessage(
        content="You are a helpful assistant that im using to make a test request to."
    ),
    HumanMessage(
        content="test from litellm. tell me why it's amazing in 1 sentence"
    ),
]
response = chat(messages)
```

Request with base URL specified (traces when server is
[instrumented](https://dd.datad0g.com/llm/traces?query=%40ml_app%3Anicole-test%20%40event_type%3Aspan%20%40parent_id%3Aundefined&agg_m=count&agg_m_source=base&agg_t=count&fromUser=true&llmPanels=%5B%7B%22t%22%3A%22sampleDetailPanel%22%2C%22rEID%22%3A%22AwAAAZc7TW9rguFD0AAAABhBWmM3VFc5ckFBREZmclJ1MU9TVUFBQUEAAABdMTE5NzNiNGQtNmY4Zi00NjNlLWIxZGUtNmUzYmRiN2I0Y2E0LXN5bnRoZXRpYy10aW1lLTE3NDkwNDU2MDAwMDAwMDAwMDBjLTE3NDkwNDY2MjAwNDcwMDAwMDFvAAAADQ%22%7D%5D&sidepanelTab=trace&spanId=8307880165467569356&start=1749045735409&end=1749046635409&paused=false)
and [not
instrumented](https://dd.datad0g.com/llm/traces?query=%40ml_app%3Anicole-test%20%40event_type%3Aspan%20%40parent_id%3Aundefined&agg_m=count&agg_m_source=base&agg_t=count&fromUser=false&llmPanels=%5B%7B%22t%22%3A%22sampleDetailPanel%22%2C%22rEID%22%3A%22AwAAAZc7SHY7M1vhCwAAABhBWmM3U0hZN0FBQnQ0SGJrUUR6TkFBQUEAAABdMDE5NzNiNDgtNzYzZC00NWNhLWI0MTEtMDRmZWNiY2E3NTk5LXN5bnRoZXRpYy10aW1lLTE3NDkwNDIwMDAwMDAwMDAwMDBjLTE3NDkwNDYyOTQwNzcwMDAwMDFvAAAAEw%22%7D%5D&sidepanelTab=trace&spanId=11096434266997811885&start=1749045669054&end=1749046569054&paused=false)).
```
from langchain.chat_models import ChatOpenAI
from langchain.schema import HumanMessage, SystemMessage

chat = ChatOpenAI(
    base_url="http://0.0.0.0:4000",
    model = "gpt-3.5-turbo",
    temperature=0.1,
)

messages = [
    SystemMessage(
        content="You are a helpful assistant that im using to make a test request to."
    ),
    HumanMessage(
        content="test from litellm. tell me why it's amazing in 1 sentence"
    ),
]
response = chat(messages)
```

## Open AI
Request with default base URL
([trace](https://dd.datad0g.com/llm/traces?query=%40ml_app%3Anicole-test%20%40event_type%3Aspan%20%40parent_id%3Aundefined&agg_m=count&agg_m_source=base&agg_t=count&fromUser=true&llmPanels=%5B%7B%22t%22%3A%22sampleDetailPanel%22%2C%22rEID%22%3A%22AwAAAZc7RqRAW_lvvQAAABhBWmM3UnFSQUFBQlUxWGZnS3hqUUFBQUEAAABdMTE5NzNiNDYtYTQ0MC00ODc5LTkyNjQtNzk4MTUyZDNjMWIzLXN5bnRoZXRpYy10aW1lLTE3NDkwNDIwMDAwMDAwMDAwMDBjLTE3NDkwNDYxNzQ3ODQwMDAwMDFvAAAAKQ%22%7D%5D&sidepanelTab=trace&spanId=17834548293768414476&start=1749045289463&end=1749046189463&paused=false)).
```
import os
from openai import OpenAI

oai_client = OpenAI(
    api_key=os.environ.get("OPENAI_API_KEY"),
)
completion = oai_client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[
        {"role": "user", "content": "testing openai"},
    ],
)
```
Request with base URL specified (traces when server is
[instrumented](https://dd.datad0g.com/llm/traces?query=%40ml_app%3Anicole-test%20%40event_type%3Aspan%20%40parent_id%3Aundefined&agg_m=count&agg_m_source=base&agg_t=count&fromUser=false&llmPanels=%5B%7B%22t%22%3A%22sampleDetailPanel%22%2C%22rEID%22%3A%22AwAAAZc7RWmuM0bhCwAAABhBWmM3UldtdUFBQU9zWkQtVkdQN0FBQUEAAABdMDE5NzNiNDUtNjlkMC00NjViLTg1NzYtMGUyZGFjMWE2OTUwLXN5bnRoZXRpYy10aW1lLTE3NDkwNDIwMDAwMDAwMDAwMDBjLTE3NDkwNDYwOTQyODgwMDAwMDFvAAAAIg%22%7D%5D&sidepanelTab=trace&spanId=11019904099175727297&start=1749045219049&end=1749046119049&paused=false)
and [not
instrumented](https://dd.datad0g.com/llm/traces?query=%40ml_app%3Anicole-test%20%40event_type%3Aspan%20%40parent_id%3Aundefined&agg_m=count&agg_m_source=base&agg_t=count&fromUser=true&llmPanels=%5B%7B%22t%22%3A%22sampleDetailPanel%22%2C%22rEID%22%3A%22AwAAAZc7Rn0emfEClAAAABhBWmM3Um4wZUFBQXpZb2NnbzNRTUFBQUEAAABdMTE5NzNiNDYtN2QxZS00MThkLTg4MzItYzVmMDNmNjZkN2YxLXN5bnRoZXRpYy10aW1lLTE3NDkwNDIwMDAwMDAwMDAwMDBjLTE3NDkwNDYxNjQ3NjYwMDAwMDFvAAAARw%22%7D%5D&sidepanelTab=trace&spanId=4955295909966002358&start=1749045278443&end=1749046178443&paused=false)).
```
import os
from openai import OpenAI

oai_client = OpenAI(
    api_key=os.environ.get("OPENAI_API_KEY"),
    base_url="http://0.0.0.0:4000",
)
completion = oai_client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[
        {"role": "user", "content": "testing openai"},
    ],
)
```


## Checklist
- [x] PR author has checked that all the criteria below are met
- The PR description includes an overview of the change
- The PR description articulates the motivation for the change
- The change includes tests OR the PR description describes a testing
strategy
- The PR description notes risks associated with the change, if any
- Newly-added code is easy to change
- The change follows the [library release note
guidelines](https://ddtrace.readthedocs.io/en/stable/releasenotes.html)
- The change includes or references documentation updates if necessary
- Backport labels are set (if
[applicable](https://ddtrace.readthedocs.io/en/latest/contributing.html#backporting))

## Reviewer Checklist
- [x] Reviewer has checked that all the criteria below are met 
- Title is accurate
- All changes are related to the pull request's stated goal
- Avoids breaking
[API](https://ddtrace.readthedocs.io/en/stable/versioning.html#interfaces)
changes
- Testing strategy adequately addresses listed risks
- Newly-added code is easy to change
- Release note makes sense to a user of the library
- If necessary, author has acknowledged and discussed the performance
implications of this PR as reported in the benchmarks PR comment
- Backport labels are set in a manner that is consistent with the
[release branch maintenance
policy](https://ddtrace.readthedocs.io/en/latest/contributing.html#backporting)

Author: ncybul

ddtrace/contrib/internal/anthropic/patch.py

@@ -43,14 +43,11 @@ def traced_chat_model_generate(anthropic, pin, func, instance, args, kwargs):
     chat_messages = get_argument_value(args, kwargs, 0, "messages")
     integration = anthropic._datadog_integration
     stream = False
-    client = getattr(instance, "_client", None)
-    base_url = getattr(client, "_base_url", None) if client else None
 
     span = integration.trace(
         pin,
         "%s.%s" % (instance.__class__.__name__, func.__name__),
-        # only report LLM Obs spans if base_url has not been changed
-        submit_to_llmobs=integration.is_default_base_url(str(base_url) if base_url else None),
+        submit_to_llmobs=True,
         interface_type="chat_model",
         provider="anthropic",
         model=kwargs.get("model", ""),
@@ -118,14 +115,11 @@ async def traced_async_chat_model_generate(anthropic, pin, func, instance, args,
     chat_messages = get_argument_value(args, kwargs, 0, "messages")
     integration = anthropic._datadog_integration
     stream = False
-    client = getattr(instance, "_client", None)
-    base_url = getattr(client, "_base_url", None) if client else None
 
     span = integration.trace(
         pin,
         "%s.%s" % (instance.__class__.__name__, func.__name__),
-        # only report LLM Obs spans if base_url has not been changed
-        submit_to_llmobs=integration.is_default_base_url(str(base_url) if base_url else None),
+        submit_to_llmobs=True,
         interface_type="chat_model",
         provider="anthropic",
         model=kwargs.get("model", ""),

ddtrace/contrib/internal/botocore/services/bedrock.py

@@ -493,14 +493,7 @@ def patched_bedrock_api_call(original_func, instance, args, kwargs, function_var
     model_id = params.get("modelId")
     model_provider, model_name = _parse_model_id(model_id)
     integration = function_vars.get("integration")
-    endpoint = getattr(instance, "_endpoint", None)
-    endpoint_host = getattr(endpoint, "host", None) if endpoint else None
-    # only report LLM Obs spans if base_url has not been changed
-    submit_to_llmobs = (
-        integration.llmobs_enabled
-        and "embed" not in model_name
-        and integration.is_default_base_url(str(endpoint_host) if endpoint_host else None)
-    )
+    submit_to_llmobs = integration.llmobs_enabled and "embed" not in model_name
     with core.context_with_data(
         "botocore.patched_bedrock_api_call",
         pin=pin,

ddtrace/contrib/internal/langchain/patch.py

@@ -171,8 +171,7 @@ def traced_llm_generate(langchain, pin, func, instance, args, kwargs):
     span = integration.trace(
         pin,
         "%s.%s" % (instance.__module__, instance.__class__.__name__),
-        # only report LLM Obs spans if base_url has not been changed
-        submit_to_llmobs=integration.has_default_base_url(instance),
+        submit_to_llmobs=True,
         interface_type="llm",
         provider=llm_provider,
         model=model,
@@ -230,8 +229,7 @@ async def traced_llm_agenerate(langchain, pin, func, instance, args, kwargs):
     span = integration.trace(
         pin,
         "%s.%s" % (instance.__module__, instance.__class__.__name__),
-        # only report LLM Obs spans if base_url has not been changed
-        submit_to_llmobs=integration.has_default_base_url(instance),
+        submit_to_llmobs=True,
         interface_type="llm",
         provider=llm_provider,
         model=model,
@@ -288,8 +286,7 @@ def traced_chat_model_generate(langchain, pin, func, instance, args, kwargs):
     span = integration.trace(
         pin,
         "%s.%s" % (instance.__module__, instance.__class__.__name__),
-        # only report LLM Obs spans if base_url has not been changed
-        submit_to_llmobs=integration.has_default_base_url(instance),
+        submit_to_llmobs=True,
         interface_type="chat_model",
         provider=llm_provider,
         model=_extract_model_name(instance),
@@ -385,8 +382,7 @@ async def traced_chat_model_agenerate(langchain, pin, func, instance, args, kwar
     span = integration.trace(
         pin,
         "%s.%s" % (instance.__module__, instance.__class__.__name__),
-        # only report LLM Obs spans if base_url has not been changed
-        submit_to_llmobs=integration.has_default_base_url(instance),
+        submit_to_llmobs=True,
         interface_type="chat_model",
         provider=llm_provider,
         model=_extract_model_name(instance),

ddtrace/contrib/internal/langchain/utils.py

@@ -84,10 +84,7 @@ def shared_stream(
         "pin": pin,
         "operation_id": f"{instance.__module__}.{instance.__class__.__name__}",
         "interface_type": interface_type,
-        # submit to llmobs only if we detect an LLM request that is not being sent to a proxy
-        "submit_to_llmobs": (
-            integration.has_default_base_url(instance) if interface_type in ("chat_model", "llm") else True
-        ),
+        "submit_to_llmobs": True,
     }
 
     options.update(extra_options)

ddtrace/contrib/internal/openai/patch.py

@@ -206,14 +206,7 @@ def patched_completions_with_raw_response_init(openai, pin, func, instance, args
 
 
 def _traced_endpoint(endpoint_hook, integration, instance, pin, args, kwargs):
-    client = getattr(instance, "_client", None)
-    base_url = getattr(client, "_base_url", None) if client else None
-
-    span = integration.trace(
-        pin,
-        endpoint_hook.OPERATION_ID,
-        base_url=base_url,
-    )
+    span = integration.trace(pin, endpoint_hook.OPERATION_ID)
     openai_api_key = _format_openai_api_key(kwargs.get("api_key"))
     resp, err = None, None
     if openai_api_key:

ddtrace/llmobs/_integrations/anthropic.py

@@ -5,7 +5,6 @@
 from typing import List
 from typing import Optional
 from typing import Union
-from urllib.parse import urlparse
 
 from ddtrace.internal.logger import get_logger
 from ddtrace.llmobs._constants import INPUT_MESSAGES
@@ -26,7 +25,6 @@
 
 API_KEY = "anthropic.request.api_key"
 MODEL = "anthropic.request.model"
-DEFAULT_ANTHROPIC_HOSTNAME = "api.anthropic.com"
 
 
 class AnthropicIntegration(BaseLLMIntegration):
@@ -190,10 +188,3 @@ def record_usage(self, span: Span, usage: Dict[str, Any]) -> None:
             span.set_metric("anthropic.response.usage.output_tokens", output_tokens)
         if input_tokens is not None and output_tokens is not None:
             span.set_metric("anthropic.response.usage.total_tokens", input_tokens + output_tokens)
-
-    def is_default_base_url(self, base_url: Optional[str] = None) -> bool:
-        if base_url is None:
-            return True
-
-        parsed_url = urlparse(base_url)
-        return parsed_url.hostname == DEFAULT_ANTHROPIC_HOSTNAME

ddtrace/llmobs/_integrations/bedrock.py

@@ -1,10 +1,8 @@
-import re
 from typing import Any
 from typing import Dict
 from typing import List
 from typing import Optional
 from typing import Tuple
-from urllib.parse import urlparse
 
 from ddtrace.internal.logger import get_logger
 from ddtrace.llmobs._constants import INPUT_MESSAGES
@@ -22,8 +20,6 @@
 
 log = get_logger(__name__)
 
-BEDROCK_URL_REGEX_PATTERN = "^bedrock-runtime[\\w.-]*.com$"
-
 
 class BedrockIntegration(BaseLLMIntegration):
     _integration_name = "bedrock"
@@ -271,11 +267,3 @@ def _extract_output_message(response):
                 return [{"content": str(content)} for content in response["text"]]
             if isinstance(response["text"][0], dict):
                 return [{"content": response["text"][0].get("text", "")}]
-
-    def is_default_base_url(self, base_url: Optional[str] = None) -> bool:
-        if base_url is None:
-            return True
-
-        parsed_url = urlparse(base_url)
-        default_url_regex = re.compile(BEDROCK_URL_REGEX_PATTERN)
-        return default_url_regex.match(parsed_url.hostname or "") is not None

ddtrace/llmobs/_integrations/langchain.py

@@ -30,7 +30,6 @@
 from ddtrace.llmobs._constants import TOTAL_TOKENS_METRIC_KEY
 from ddtrace.llmobs._integrations.base import BaseLLMIntegration
 from ddtrace.llmobs._integrations.utils import format_langchain_io
-from ddtrace.llmobs._integrations.utils import is_openai_default_base_url
 from ddtrace.llmobs._utils import _get_nearest_llmobs_ancestor
 from ddtrace.llmobs.utils import Document
 from ddtrace.trace import Span
@@ -726,7 +725,3 @@ def check_token_usage_ai_message(self, ai_message):
         total_tokens = usage.get("total_tokens", input_tokens + output_tokens)
 
         return (input_tokens, output_tokens, total_tokens), run_id_base
-
-    def has_default_base_url(self, instance) -> bool:
-        openai_api_base = getattr(instance, "openai_api_base", None)
-        return not openai_api_base or is_openai_default_base_url(openai_api_base)

ddtrace/llmobs/_integrations/openai.py

@@ -18,7 +18,6 @@
 from ddtrace.llmobs._constants import TOTAL_TOKENS_METRIC_KEY
 from ddtrace.llmobs._integrations.base import BaseLLMIntegration
 from ddtrace.llmobs._integrations.utils import get_llmobs_metrics_tags
-from ddtrace.llmobs._integrations.utils import is_openai_default_base_url
 from ddtrace.llmobs._integrations.utils import openai_set_meta_tags_from_chat
 from ddtrace.llmobs._integrations.utils import openai_set_meta_tags_from_completion
 from ddtrace.llmobs._utils import _get_attr
@@ -53,10 +52,8 @@ def user_api_key(self, value: str) -> None:
         self._user_api_key = "sk-...%s" % value[-4:]
 
     def trace(self, pin: Pin, operation_id: str, submit_to_llmobs: bool = False, **kwargs: Dict[str, Any]) -> Span:
-        base_url = kwargs.get("base_url", None)
-        submit_to_llmobs = self.is_default_base_url(str(base_url) if base_url else None) and (
-            operation_id.endswith("Completion") or operation_id == "createEmbedding"
-        )
+        if operation_id.endswith("Completion") or operation_id == "createEmbedding":
+            submit_to_llmobs = True
         return super().trace(pin, operation_id, submit_to_llmobs, **kwargs)
 
     def _set_base_span_tags(self, span: Span, **kwargs) -> None:
@@ -171,6 +168,3 @@ def _extract_llmobs_metrics_tags(span: Span, resp: Any) -> Dict[str, Any]:
                 TOTAL_TOKENS_METRIC_KEY: prompt_tokens + completion_tokens,
             }
         return get_llmobs_metrics_tags("openai", span)
-
-    def is_default_base_url(self, base_url: Optional[str] = None) -> bool:
-        return is_openai_default_base_url(base_url)

ddtrace/llmobs/_integrations/utils.py

@@ -2,14 +2,12 @@
 from dataclasses import dataclass
 from dataclasses import is_dataclass
 import json
-import re
 from typing import Any
 from typing import Dict
 from typing import List
 from typing import Optional
 from typing import Tuple
 from typing import Union
-from urllib.parse import urlparse
 
 from ddtrace._trace.span import Span
 from ddtrace.internal import core
@@ -31,8 +29,6 @@
 
 logger = get_logger(__name__)
 
-ACCEPTED_OPENAI_DEFAULT_HOSTNAMES = ("api.openai.com", "api.deepseek.com")
-AZURE_URL_REGEX_PATTERN = "^[\\w.-]*openai\\.azure\\.com$"
 OPENAI_SKIPPED_COMPLETION_TAGS = (
     "model",
     "prompt",
@@ -53,16 +49,6 @@
 )
 
 
-def is_openai_default_base_url(base_url: Optional[str] = None) -> bool:
-    if base_url is None:
-        return True
-
-    parsed_url = urlparse(base_url)
-    default_azure_endpoint_regex = re.compile(AZURE_URL_REGEX_PATTERN)
-    matches_azure_endpoint = default_azure_endpoint_regex.match(parsed_url.hostname or "") is not None
-    return parsed_url.hostname in ACCEPTED_OPENAI_DEFAULT_HOSTNAMES or matches_azure_endpoint
-
-
 def extract_model_name_google(instance, model_name_attr):
     """Extract the model name from the instance.
     Model names are stored in the format `"models/{model_name}"`