File Manager

X7ROOT File Manager

Current Path: /opt/hc_python/lib/python3.12/site-packages/sentry_sdk/integrations

opt / hc_python / lib / python3.12 / site-packages / sentry_sdk / integrations /

?? ..
?? __init__.py(12.51 KB)
?? __pycache__
?? _asgi_common.py(4 KB)
?? _wsgi_common.py(7.28 KB)
?? aiohttp.py(19.28 KB)
?? aiomysql.py(9.09 KB)
?? anthropic.py(39 KB)
?? argv.py(876 B)
?? ariadne.py(5.7 KB)
?? arq.py(9.23 KB)
?? asgi.py(20.06 KB)
?? asyncio.py(9.28 KB)
?? asyncpg.py(9.68 KB)
?? atexit.py(1.51 KB)
?? aws_lambda.py(17.41 KB)
?? beam.py(4.91 KB)
?? boto3.py(6.2 KB)
?? bottle.py(7.21 KB)
?? celery
?? chalice.py(4.51 KB)
?? clickhouse_driver.py(5.85 KB)
?? cloud_resource_context.py(7.49 KB)
?? cohere.py(10.44 KB)
?? dedupe.py(1.86 KB)
?? django
?? dramatiq.py(8.02 KB)
?? excepthook.py(2.25 KB)
?? executing.py(1.93 KB)
?? falcon.py(9.04 KB)
?? fastapi.py(5.28 KB)
?? flask.py(8.27 KB)
?? gcp.py(10.57 KB)
?? gnu_backtrace.py(2.72 KB)
?? google_genai
?? gql.py(4.93 KB)
?? graphene.py(5.71 KB)
?? grpc
?? httpx.py(9.79 KB)
?? httpx2.py(9.8 KB)
?? huey.py(8.19 KB)
?? huggingface_hub.py(15.28 KB)
?? langchain.py(48.31 KB)
?? langgraph.py(18.13 KB)
?? launchdarkly.py(1.87 KB)
?? litellm.py(13.03 KB)
?? litestar.py(11.46 KB)
?? logging.py(15.69 KB)
?? loguru.py(6.35 KB)
?? mcp.py(23.12 KB)
?? modules.py(787 B)
?? openai.py(53.38 KB)
?? openai_agents
?? openfeature.py(1.08 KB)
?? opentelemetry
?? otlp.py(7.99 KB)
?? pure_eval.py(4.41 KB)
?? pydantic_ai
?? pymongo.py(8.21 KB)
?? pyramid.py(7.42 KB)
?? pyreqwest.py(6.82 KB)
?? quart.py(7.32 KB)
?? ray.py(5.75 KB)
?? redis
?? rq.py(7.81 KB)
?? rust_tracing.py(9.44 KB)
?? sanic.py(15.25 KB)
?? serverless.py(1.58 KB)
?? socket.py(5.02 KB)
?? spark
?? sqlalchemy.py(5.24 KB)
?? starlette.py(27.93 KB)
?? starlite.py(11.04 KB)
?? statsig.py(1.19 KB)
?? stdlib.py(14.01 KB)
?? strawberry.py(17.39 KB)
?? sys_exit.py(2.35 KB)
?? threading.py(6.88 KB)
?? tornado.py(10.79 KB)
?? trytond.py(1.67 KB)
?? typer.py(1.72 KB)
?? unleash.py(1.02 KB)
?? unraisablehook.py(1.65 KB)
?? wsgi.py(15.03 KB)

Editing: cohere.py

import sys
from functools import wraps
from typing import TYPE_CHECKING

from sentry_sdk import consts
from sentry_sdk.ai.monitoring import record_token_usage
from sentry_sdk.ai.utils import get_start_span_function, set_data_normalized
from sentry_sdk.consts import SPANDATA
from sentry_sdk.traces import StreamedSpan
from sentry_sdk.tracing_utils import has_span_streaming_enabled

if TYPE_CHECKING:
    from typing import Any, Callable, Iterator, Union

from sentry_sdk.tracing import Span

import sentry_sdk
from sentry_sdk.integrations import DidNotEnable, Integration
from sentry_sdk.scope import should_send_default_pii
from sentry_sdk.utils import capture_internal_exceptions, event_from_exception, reraise

try:
    from cohere import (
        ChatStreamEndEvent,
        NonStreamedChatResponse,
    )
    from cohere.base_client import BaseCohere
    from cohere.client import Client

if TYPE_CHECKING:
        from cohere import StreamedChatResponse
except ImportError:
    raise DidNotEnable("Cohere not installed")

try:
    # cohere 5.9.3+
    from cohere import StreamEndStreamedChatResponse
except ImportError:
    from cohere import StreamedChatResponse_StreamEnd as StreamEndStreamedChatResponse

COLLECTED_CHAT_PARAMS = {
    "model": SPANDATA.AI_MODEL_ID,
    "k": SPANDATA.AI_TOP_K,
    "p": SPANDATA.AI_TOP_P,
    "seed": SPANDATA.AI_SEED,
    "frequency_penalty": SPANDATA.AI_FREQUENCY_PENALTY,
    "presence_penalty": SPANDATA.AI_PRESENCE_PENALTY,
    "raw_prompting": SPANDATA.AI_RAW_PROMPTING,
}

COLLECTED_PII_CHAT_PARAMS = {
    "tools": SPANDATA.AI_TOOLS,
    "preamble": SPANDATA.AI_PREAMBLE,
}

COLLECTED_CHAT_RESP_ATTRS = {
    "generation_id": SPANDATA.AI_GENERATION_ID,
    "is_search_required": SPANDATA.AI_SEARCH_REQUIRED,
    "finish_reason": SPANDATA.AI_FINISH_REASON,
}

COLLECTED_PII_CHAT_RESP_ATTRS = {
    "citations": SPANDATA.AI_CITATIONS,
    "documents": SPANDATA.AI_DOCUMENTS,
    "search_queries": SPANDATA.AI_SEARCH_QUERIES,
    "search_results": SPANDATA.AI_SEARCH_RESULTS,
    "tool_calls": SPANDATA.AI_TOOL_CALLS,
}

class CohereIntegration(Integration):
    identifier = "cohere"
    origin = f"auto.ai.{identifier}"

def __init__(self: "CohereIntegration", include_prompts: bool = True) -> None:
        self.include_prompts = include_prompts

@staticmethod
    def setup_once() -> None:
        BaseCohere.chat = _wrap_chat(BaseCohere.chat, streaming=False)
        Client.embed = _wrap_embed(Client.embed)
        BaseCohere.chat_stream = _wrap_chat(BaseCohere.chat_stream, streaming=True)

def _capture_exception(exc: "Any") -> None:
    event, hint = event_from_exception(
        exc,
        client_options=sentry_sdk.get_client().options,
        mechanism={"type": "cohere", "handled": False},
    )
    sentry_sdk.capture_event(event, hint=hint)

def _end_span(span: "Any") -> None:
    if isinstance(span, StreamedSpan):
        span.end()
    else:
        span.__exit__(None, None, None)

def _wrap_chat(f: "Callable[..., Any]", streaming: bool) -> "Callable[..., Any]":
    def collect_chat_response_fields(
        span: "Union[Span, StreamedSpan]",
        res: "NonStreamedChatResponse",
        include_pii: bool,
    ) -> None:
        if include_pii:
            if hasattr(res, "text"):
                set_data_normalized(
                    span,
                    SPANDATA.AI_RESPONSES,
                    [res.text],
                )
            for pii_attr in COLLECTED_PII_CHAT_RESP_ATTRS:
                if hasattr(res, pii_attr):
                    set_data_normalized(span, "ai." + pii_attr, getattr(res, pii_attr))

for attr in COLLECTED_CHAT_RESP_ATTRS:
            if hasattr(res, attr):
                set_data_normalized(span, "ai." + attr, getattr(res, attr))

if hasattr(res, "meta"):
            if hasattr(res.meta, "billed_units"):
                record_token_usage(
                    span,
                    input_tokens=res.meta.billed_units.input_tokens,
                    output_tokens=res.meta.billed_units.output_tokens,
                )
            elif hasattr(res.meta, "tokens"):
                record_token_usage(
                    span,
                    input_tokens=res.meta.tokens.input_tokens,
                    output_tokens=res.meta.tokens.output_tokens,
                )

if hasattr(res.meta, "warnings"):
                set_data_normalized(span, SPANDATA.AI_WARNINGS, res.meta.warnings)

@wraps(f)
    def new_chat(*args: "Any", **kwargs: "Any") -> "Any":
        integration = sentry_sdk.get_client().get_integration(CohereIntegration)
        is_span_streaming_enabled = has_span_streaming_enabled(
            sentry_sdk.get_client().options
        )

if (
            integration is None
            or "message" not in kwargs
            or not isinstance(kwargs.get("message"), str)
        ):
            return f(*args, **kwargs)

message = kwargs.get("message")

if is_span_streaming_enabled:
            span = sentry_sdk.traces.start_span(
                name="cohere.client.Chat",
                attributes={
                    "sentry.op": consts.OP.COHERE_CHAT_COMPLETIONS_CREATE,
                    "sentry.origin": CohereIntegration.origin,
                },
            )
        else:
            span = get_start_span_function()(
                op=consts.OP.COHERE_CHAT_COMPLETIONS_CREATE,
                name="cohere.client.Chat",
                origin=CohereIntegration.origin,
            )
            span.__enter__()
        try:
            res = f(*args, **kwargs)
        except Exception as e:
            exc_info = sys.exc_info()
            with capture_internal_exceptions():
                _capture_exception(e)
                span.__exit__(*exc_info)

reraise(*exc_info)

with capture_internal_exceptions():
            if should_send_default_pii() and integration.include_prompts:
                set_data_normalized(
                    span,
                    SPANDATA.AI_INPUT_MESSAGES,
                    list(
                        map(
                            lambda x: {
                                "role": getattr(x, "role", "").lower(),
                                "content": getattr(x, "message", ""),
                            },
                            kwargs.get("chat_history", []),
                        )
                    )
                    + [{"role": "user", "content": message}],
                )
                for k, v in COLLECTED_PII_CHAT_PARAMS.items():
                    if k in kwargs:
                        set_data_normalized(span, v, kwargs[k])

for k, v in COLLECTED_CHAT_PARAMS.items():
                if k in kwargs:
                    set_data_normalized(span, v, kwargs[k])
            set_data_normalized(span, SPANDATA.AI_STREAMING, False)

if streaming:
                old_iterator = res

def new_iterator() -> "Iterator[StreamedChatResponse]":
                    with capture_internal_exceptions():
                        for x in old_iterator:
                            if isinstance(x, ChatStreamEndEvent) or isinstance(
                                x, StreamEndStreamedChatResponse
                            ):
                                collect_chat_response_fields(
                                    span,
                                    x.response,
                                    include_pii=should_send_default_pii()
                                    and integration.include_prompts,
                                )
                            yield x
                    _end_span(span)

return new_iterator()
            elif isinstance(res, NonStreamedChatResponse):
                collect_chat_response_fields(
                    span,
                    res,
                    include_pii=should_send_default_pii()
                    and integration.include_prompts,
                )
                _end_span(span)
            else:
                set_data_normalized(span, "unknown_response", True)
                _end_span(span)
        return res

return new_chat

def _wrap_embed(f: "Callable[..., Any]") -> "Callable[..., Any]":
    @wraps(f)
    def new_embed(*args: "Any", **kwargs: "Any") -> "Any":
        integration = sentry_sdk.get_client().get_integration(CohereIntegration)
        if integration is None:
            return f(*args, **kwargs)

is_span_streaming_enabled = has_span_streaming_enabled(
            sentry_sdk.get_client().options
        )

if is_span_streaming_enabled:
            span_ctx = sentry_sdk.traces.start_span(
                name="Cohere Embedding Creation",
                attributes={
                    "sentry.op": consts.OP.COHERE_EMBEDDINGS_CREATE,
                    "sentry.origin": CohereIntegration.origin,
                },
            )
        else:
            span_ctx = get_start_span_function()(
                op=consts.OP.COHERE_EMBEDDINGS_CREATE,
                name="Cohere Embedding Creation",
                origin=CohereIntegration.origin,
            )

with span_ctx as span:
            if "texts" in kwargs and (
                should_send_default_pii() and integration.include_prompts
            ):
                if isinstance(kwargs["texts"], str):
                    set_data_normalized(span, SPANDATA.AI_TEXTS, [kwargs["texts"]])
                elif (
                    isinstance(kwargs["texts"], list)
                    and len(kwargs["texts"]) > 0
                    and isinstance(kwargs["texts"][0], str)
                ):
                    set_data_normalized(
                        span, SPANDATA.AI_INPUT_MESSAGES, kwargs["texts"]
                    )

if "model" in kwargs:
                set_data_normalized(span, SPANDATA.AI_MODEL_ID, kwargs["model"])
            try:
                res = f(*args, **kwargs)
            except Exception as e:
                exc_info = sys.exc_info()
                with capture_internal_exceptions():
                    _capture_exception(e)
                reraise(*exc_info)
            if (
                hasattr(res, "meta")
                and hasattr(res.meta, "billed_units")
                and hasattr(res.meta.billed_units, "input_tokens")
            ):
                record_token_usage(
                    span,
                    input_tokens=res.meta.billed_units.input_tokens,
                    total_tokens=res.meta.billed_units.input_tokens,
                )
            return res

return new_embed

X7ROOT File Manager

Editing: cohere.py

Upload File

Create Folder