monocle-apptrace 0.3.1b1__tar.gz → 0.4.0b1__tar.gz

{monocle_apptrace-0.3.1b1 → monocle_apptrace-0.4.0b1}/.gitignore

@@ -13,4 +13,5 @@ dist
 .tox
 .DS_Store
 Pipfile**
-launch.json
+launch.json
+monocle_trace**.json

{monocle_apptrace-0.3.1b1 → monocle_apptrace-0.4.0b1}/CHANGELOG.md

@@ -1,12 +1,28 @@
-## Version 0.3.1b1 (2024-04-14)
+## Version 0.4.0b1 (2025-05-14)
+
+- Added conversation id in scope for teams ai bot ([#180](https://github.com/monocle2ai/monocle/pull/180))
+- Update inference entity type of TeamsAI SDK ([#178](https://github.com/monocle2ai/monocle/pull/178))
+- Added stream and async for openai ([#177](https://github.com/monocle2ai/monocle/pull/177))
+- Update inference span of TeamsAI ([#176](https://github.com/monocle2ai/monocle/pull/176))
+- Remove Preset span name and Bugfix for Event ([#175](https://github.com/monocle2ai/monocle/pull/175))
+- Add haystack anthropic sample ([#174](https://github.com/monocle2ai/monocle/pull/174))
+- aiohttp auto instrumentation ([#173](https://github.com/monocle2ai/monocle/pull/173))
+- Add source path to spans and fix json syntax in file exporter ([#172](https://github.com/monocle2ai/monocle/pull/172))
+- Added changes for openai streaming ([#171](https://github.com/monocle2ai/monocle/pull/171))
+- Add llama index anthropic sample ([#170](https://github.com/monocle2ai/monocle/pull/170))
+
+## Version 0.3.1 (2024-04-18)
 
 - Add MetaModel for Anthropic SDK ([#159](https://github.com/monocle2ai/monocle/pull/159))
 - Add openAI response for openAI and AzureOpenAI ([#158](https://github.com/monocle2ai/monocle/pull/158))
 - Update retrieval span for Boto Client ([#157](https://github.com/monocle2ai/monocle/pull/157))
 - Resolve token threshold error ([#156](https://github.com/monocle2ai/monocle/pull/156))
 - Update Inference Span ([#155](https://github.com/monocle2ai/monocle/pull/155))
+- Refactor workflow and spans ([#160](https://github.com/monocle2ai/monocle/pull/160))
+- Support monocle exporter list as parameter to `setup_monocle_telemetry()` ([#161](https://github.com/monocle2ai/monocle/pull/161))
+- Add langchain anthropic sample ([#165](https://github.com/monocle2ai/monocle/pull/165))
 
-## Version 0.3.0 (2024-12-10)
+## Version 0.3.0 (2024-03-18)
 
 - Fixed issue with passing context in async case ([#150](https://github.com/monocle2ai/monocle/pull/150))
 - Added lambda processor ([#148](https://github.com/monocle2ai/monocle/pull/148))

{monocle_apptrace-0.3.1b1 → monocle_apptrace-0.4.0b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monocle_apptrace
-Version: 0.3.1b1
+Version: 0.4.0b1
 Summary: package with monocle genAI tracing
 Project-URL: Homepage, https://github.com/monocle2ai/monocle
 Project-URL: Issues, https://github.com/monocle2ai/monocle/issues

{monocle_apptrace-0.3.1b1 → monocle_apptrace-0.4.0b1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "monocle_apptrace"
-version = "0.3.1b1"
+version = "0.4.0b1"
 authors = []
 description = "package with monocle genAI tracing"
 readme = "README.md"

{monocle_apptrace-0.3.1b1 → monocle_apptrace-0.4.0b1}/src/monocle_apptrace/exporters/aws/s3_exporter.py

@@ -129,6 +129,8 @@ class S3SpanExporter(SpanExporterBase):
             # Serialize spans to JSON or any other format you prefer
             valid_json_list = []
             for span in spans:
+                if self.skip_export(span):
+                    continue
                 try:
                     valid_json_list.append(span.to_json(indent=0).replace("\n", ""))
                 except json.JSONDecodeError as e:
@@ -169,7 +171,7 @@ class S3SpanExporter(SpanExporterBase):
             Key=file_name,
             Body=span_data_batch
         )
-        logger.info(f"Span batch uploaded to AWS S3 as {file_name}.")
+        logger.debug(f"Span batch uploaded to AWS S3 as {file_name}.")
 
     async def force_flush(self, timeout_millis: int = 30000) -> bool:
         await self.__export_spans()  # Export any remaining spans in the queue

{monocle_apptrace-0.3.1b1 → monocle_apptrace-0.4.0b1}/src/monocle_apptrace/exporters/azure/blob_exporter.py

@@ -82,8 +82,8 @@ class AzureBlobSpanExporter(SpanExporterBase):
             # With Monocle,OpenTelemetry is always loaded. If the Azure trace package is installed, then it triggers the blob trace generation on every blob operation.
             # Thus, the Monocle span write ends up generating a blob span which again comes back to the exporter .. and would result in an infinite loop.
             # To avoid this, we check if the span has the Monocle SDK version attribute and skip it if it doesn't. That way the blob span genearted by Azure library are not exported.
-            if not span.attributes.get(MONOCLE_SDK_VERSION):
-                continue # TODO: All exporters to use same base class and check it there
+            if self.skip_export(span):
+                continue
             self.export_queue.append(span)
             if len(self.export_queue) >= self.max_batch_size:
                 await self.__export_spans()

{monocle_apptrace-0.3.1b1 → monocle_apptrace-0.4.0b1}/src/monocle_apptrace/exporters/base_exporter.py

@@ -1,20 +1,21 @@
-import time
+import time, os
 import random
 import logging
 from abc import ABC, abstractmethod
 from opentelemetry.sdk.trace import ReadableSpan
-from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
+from opentelemetry.sdk.trace.export import SpanExportResult
+from monocle_apptrace.instrumentation.common.constants import MONOCLE_SDK_VERSION
 from typing import Sequence
-import asyncio
 
 logger = logging.getLogger(__name__)
 
 class SpanExporterBase(ABC):
-    def __init__(self):
+    def __init__(self, export_monocle_only: bool = True):
         self.backoff_factor = 2
         self.max_retries = 10
         self.export_queue = []
         self.last_export_time = time.time()
+        self.export_monocle_only = export_monocle_only or os.environ.get("MONOCLE_EXPORTS_ONLY", True)
 
     @abstractmethod
     async def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
@@ -27,6 +28,11 @@ class SpanExporterBase(ABC):
     def shutdown(self) -> None:
         pass
 
+    def skip_export(self, span:ReadableSpan) -> bool:
+        if self.export_monocle_only and (not span.attributes.get(MONOCLE_SDK_VERSION)):
+            return True
+        return False
+
     @staticmethod
     def retry_with_backoff(retries=3, backoff_in_seconds=1, max_backoff_in_seconds=32, exceptions=(Exception,)):
         def decorator(func):

{monocle_apptrace-0.3.1b1 → monocle_apptrace-0.4.0b1}/src/monocle_apptrace/exporters/file_exporter.py

@@ -7,12 +7,13 @@ from typing import Optional, Callable, Sequence
 from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 from opentelemetry.sdk.resources import SERVICE_NAME
+from monocle_apptrace.exporters.base_exporter import SpanExporterBase
 from monocle_apptrace.exporters.exporter_processor import ExportTaskProcessor
 
 DEFAULT_FILE_PREFIX:str = "monocle_trace_"
 DEFAULT_TIME_FORMAT:str = "%Y-%m-%d_%H.%M.%S"
 
-class FileSpanExporter(SpanExporter):
+class FileSpanExporter(SpanExporterBase):
     current_trace_id: int = None
     current_file_path: str = None
 
@@ -28,6 +29,7 @@ class FileSpanExporter(SpanExporter):
         + linesep,
         task_processor: Optional[ExportTaskProcessor] = None
     ):
+        super().__init__()
         self.out_handle:TextIOWrapper = None
         self.formatter = formatter
         self.service_name = service_name
@@ -39,21 +41,32 @@ class FileSpanExporter(SpanExporter):
             self.task_processor.start()
 
     def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
+        is_root_span = any(not span.parent for span in spans)
         if self.task_processor is not None and callable(getattr(self.task_processor, 'queue_task', None)):
             # Check if any span is a root span (no parent)
-            is_root_span = any(not span.parent for span in spans)
             self.task_processor.queue_task(self._process_spans, spans, is_root_span)
             return SpanExportResult.SUCCESS
         else:
-            return self._process_spans(spans)
+            return self._process_spans(spans, is_root_span=is_root_span)
 
     def _process_spans(self, spans: Sequence[ReadableSpan], is_root_span: bool = False) -> SpanExportResult:
+        first_span:bool = True
         for span in spans:
+            if self.skip_export(span):
+                continue
             if span.context.trace_id != self.current_trace_id:
                 self.rotate_file(span.resource.attributes[SERVICE_NAME],
                                 span.context.trace_id)
+                first_span = True
+            if first_span:
+                first_span = False
+            else:
+                self.out_handle.write(",")
             self.out_handle.write(self.formatter(span))
-        self.out_handle.flush()
+        if is_root_span:
+            self.reset_handle()
+        else:
+            self.out_handle.flush()
         return SpanExportResult.SUCCESS
 
     def rotate_file(self, trace_name:str, trace_id:int) -> None:
@@ -62,6 +75,7 @@ class FileSpanExporter(SpanExporter):
                         self.file_prefix + trace_name + "_" + hex(trace_id) + "_"
                         + datetime.now().strftime(self.time_format) + ".json")
         self.out_handle = open(self.current_file_path, "w", encoding='UTF-8')
+        self.out_handle.write("[")
         self.current_trace_id = trace_id
 
     def force_flush(self, timeout_millis: int = 30000) -> bool:
@@ -70,6 +84,7 @@ class FileSpanExporter(SpanExporter):
 
     def reset_handle(self) -> None:
         if self.out_handle is not None:
+            self.out_handle.write("]")
             self.out_handle.close()
             self.out_handle = None
 

{monocle_apptrace-0.3.1b1 → monocle_apptrace-0.4.0b1}/src/monocle_apptrace/exporters/monocle_exporters.py

@@ -1,6 +1,6 @@
 from typing import Dict, Any, List
 import os
-import logging
+import logging, warnings
 from importlib import import_module
 from opentelemetry.sdk.trace.export import SpanExporter, ConsoleSpanExporter
 from monocle_apptrace.exporters.exporter_processor import LambdaExportTaskProcessor, is_aws_lambda_environment
@@ -18,9 +18,12 @@ monocle_exporters: Dict[str, Any] = {
 }
 
 
-def get_monocle_exporter() -> List[SpanExporter]:
+def get_monocle_exporter(exporters_list:str=None) -> List[SpanExporter]:
     # Retrieve the MONOCLE_EXPORTER environment variable and split it into a list
-    exporter_names = os.environ.get("MONOCLE_EXPORTER", "file").split(",")
+    if exporters_list:
+        exporter_names = exporters_list.split(",")
+    else:
+        exporter_names = os.environ.get("MONOCLE_EXPORTER", "file").split(",")
     exporters = []
     
     # Create task processor for AWS Lambda environment
@@ -31,7 +34,7 @@ def get_monocle_exporter() -> List[SpanExporter]:
         try:
             exporter_class_path = monocle_exporters[exporter_name]
         except KeyError:
-            logger.debug(f"Unsupported Monocle span exporter '{exporter_name}', skipping.")
+            warnings.warn(f"Unsupported Monocle span exporter '{exporter_name}', skipping.")
             continue
         try:
             exporter_module = import_module(exporter_class_path["module"])
@@ -42,7 +45,7 @@ def get_monocle_exporter() -> List[SpanExporter]:
             else:
                 exporters.append(exporter_class())
         except Exception as ex:
-            logger.debug(
+            warnings.warn(
                 f"Unable to initialize Monocle span exporter '{exporter_name}', error: {ex}. Using ConsoleSpanExporter as a fallback.")
             exporters.append(ConsoleSpanExporter())
             continue

{monocle_apptrace-0.3.1b1 → monocle_apptrace-0.4.0b1}/src/monocle_apptrace/exporters/okahu/okahu_exporter.py

@@ -6,7 +6,7 @@ import requests
 from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult, ConsoleSpanExporter
 from requests.exceptions import ReadTimeout
-
+from monocle_apptrace.exporters.base_exporter import SpanExporterBase
 from monocle_apptrace.exporters.exporter_processor import ExportTaskProcessor
 
 REQUESTS_SUCCESS_STATUS_CODES = (200, 202)
@@ -15,7 +15,7 @@ OKAHU_PROD_INGEST_ENDPOINT = "https://ingest.okahu.co/api/v1/trace/ingest"
 logger = logging.getLogger(__name__)
 
 
-class OkahuSpanExporter(SpanExporter):
+class OkahuSpanExporter(SpanExporterBase):
     def __init__(
             self,
             endpoint: Optional[str] = None,
@@ -24,6 +24,7 @@ class OkahuSpanExporter(SpanExporter):
             task_processor: ExportTaskProcessor = None
     ):
         """Okahu exporter."""
+        super().__init__()
         okahu_endpoint: str = os.environ.get("OKAHU_INGESTION_ENDPOINT", OKAHU_PROD_INGEST_ENDPOINT)
         self.endpoint = endpoint or okahu_endpoint
         api_key: str = os.environ.get("OKAHU_API_KEY")
@@ -58,6 +59,8 @@ class OkahuSpanExporter(SpanExporter):
 
         # append the batch object with all the spans object
         for span in spans:
+            if self.skip_export(span):
+                continue
             # create a object from serialized span
             obj = json.loads(span.to_json())
             if obj["parent_id"] is None:

{monocle_apptrace-0.3.1b1 → monocle_apptrace-0.4.0b1}/src/monocle_apptrace/instrumentation/common/__init__.py

@@ -1,2 +1,2 @@
 from .instrumentor import setup_monocle_telemetry, start_trace, stop_trace, start_scope, stop_scope, http_route_handler, monocle_trace_scope, monocle_trace_scope_method, monocle_trace
-from .utils import MonocleSpanException
+from .utils import MonocleSpanException

{monocle_apptrace-0.3.1b1 → monocle_apptrace-0.4.0b1}/src/monocle_apptrace/instrumentation/common/constants.py

@@ -51,6 +51,9 @@ llm_type_map = {
     "openaigenerator": "openai",
     "bedrockruntime":"aws_bedrock",
     "sagemakerruntime":"aws_sagemaker",
+    "anthropic": "anthropic",
+    "chatanthropic":"anthropic",
+    "anthropicchatgenerator":"anthropic",
 }
 
 MONOCLE_INSTRUMENTOR = "monocle_apptrace"
@@ -70,5 +73,9 @@ SCOPE_METHOD_FILE = 'monocle_scopes.json'
 SCOPE_CONFIG_PATH = 'MONOCLE_SCOPE_CONFIG_PATH'
 TRACE_PROPOGATION_URLS = "MONOCLE_TRACE_PROPAGATATION_URLS"
 WORKFLOW_TYPE_KEY = "monocle.workflow_type"
+ADD_NEW_WORKFLOW = "monocle.add_new_workflow"
 WORKFLOW_TYPE_GENERIC = "workflow.generic"
-MONOCLE_SDK_VERSION = "monocle_apptrace.version"
+MONOCLE_SDK_VERSION = "monocle_apptrace.version"
+MONOCLE_SDK_LANGUAGE = "monocle_apptrace.language"
+MONOCLE_DETECTED_SPAN_ERROR = "monocle_apptrace.detected_span_error"
+HTTP_SUCCESS_CODES = ('200', '201', '202', '204', '205', '206')

{monocle_apptrace-0.3.1b1 → monocle_apptrace-0.4.0b1}/src/monocle_apptrace/instrumentation/common/instrumentor.py

@@ -3,6 +3,7 @@ import inspect
 from typing import Collection, Dict, List, Union
 import random
 import uuid
+import inspect
 from opentelemetry import trace
 from contextlib import contextmanager
 from opentelemetry.context import attach, get_value, set_value, get_current, detach
@@ -13,6 +14,7 @@ from opentelemetry.sdk.trace import TracerProvider, Span, id_generator
 from opentelemetry.sdk.resources import SERVICE_NAME, Resource
 from opentelemetry.sdk.trace import Span, TracerProvider
 from opentelemetry.sdk.trace.export import BatchSpanProcessor, SpanProcessor
+from opentelemetry.sdk.trace.export import SpanExporter
 from opentelemetry.trace import get_tracer
 from wrapt import wrap_function_wrapper
 from opentelemetry.trace.propagation import set_span_in_context, _SPAN_KEY
@@ -23,11 +25,11 @@ from monocle_apptrace.instrumentation.common.wrapper_method import (
     WrapperMethod,
     MONOCLE_SPAN_HANDLERS
 )
-from monocle_apptrace.instrumentation.common.wrapper import scope_wrapper, ascope_wrapper, wrapper_processor
+from monocle_apptrace.instrumentation.common.wrapper import scope_wrapper, ascope_wrapper, monocle_wrapper, amonocle_wrapper
 from monocle_apptrace.instrumentation.common.utils import (
-    set_scope, remove_scope, http_route_handler, load_scopes, async_wrapper, http_async_route_handler
+    set_scope, remove_scope, http_route_handler, load_scopes, http_async_route_handler
 )
-from monocle_apptrace.instrumentation.common.constants import MONOCLE_INSTRUMENTOR, WORKFLOW_TYPE_KEY
+from monocle_apptrace.instrumentation.common.constants import MONOCLE_INSTRUMENTOR, WORKFLOW_TYPE_GENERIC
 from functools import wraps
 logger = logging.getLogger(__name__)
 
@@ -39,19 +41,22 @@ monocle_tracer_provider: TracerProvider = None
 
 class MonocleInstrumentor(BaseInstrumentor):
     workflow_name: str = ""
-    user_wrapper_methods: list[Union[dict,WrapperMethod]] = []
+    user_wrapper_methods: list[Union[dict,WrapperMethod]] = [],
+    exporters: list[SpanExporter] = [],
     instrumented_method_list: list[object] = []
-    handlers:Dict[str,SpanHandler] = {} # dict of handlers
+    handlers:Dict[str,SpanHandler] = None # dict of handlers
     union_with_default_methods: bool = False
 
     def __init__(
             self,
             handlers,
             user_wrapper_methods: list[Union[dict,WrapperMethod]] = None,
+            exporters: list[SpanExporter] = None,
             union_with_default_methods: bool = True
             ) -> None:
         self.user_wrapper_methods = user_wrapper_methods or []
         self.handlers = handlers
+        self.exporters = exporters
         if self.handlers is not None:
             for key, val in MONOCLE_SPAN_HANDLERS.items():
                 if key not in self.handlers:
@@ -63,13 +68,20 @@ class MonocleInstrumentor(BaseInstrumentor):
 
     def get_instrumentor(self, tracer):
         def instrumented_endpoint_invoke(to_wrap,wrapped, span_name, instance,fn):
-            @wraps(fn)
-            def with_instrumentation(*args, **kwargs):
-                async_task = inspect.iscoroutinefunction(fn)
-                boto_method_to_wrap = to_wrap.copy()
-                boto_method_to_wrap['skip_span'] = False
-                return wrapper_processor(async_task, tracer, NonFrameworkSpanHandler(),
-                            boto_method_to_wrap, fn, instance, args, kwargs)
+            if inspect.iscoroutinefunction(fn):
+                @wraps(fn)
+                async def with_instrumentation(*args, **kwargs):
+                    boto_method_to_wrap = to_wrap.copy()
+                    boto_method_to_wrap['skip_span'] = False
+                    return await amonocle_wrapper(tracer, NonFrameworkSpanHandler(),
+                            boto_method_to_wrap, fn, instance, "", args, kwargs)
+            else:
+                @wraps(fn)
+                def with_instrumentation(*args, **kwargs):
+                    boto_method_to_wrap = to_wrap.copy()
+                    boto_method_to_wrap['skip_span'] = False
+                    return monocle_wrapper(tracer, NonFrameworkSpanHandler(),
+                            boto_method_to_wrap, fn, instance, "", args, kwargs)
             return with_instrumentation
         return instrumented_endpoint_invoke
 
@@ -155,7 +167,8 @@ def setup_monocle_telemetry(
         span_processors: List[SpanProcessor] = None,
         span_handlers: Dict[str,SpanHandler] = None,
         wrapper_methods: List[Union[dict,WrapperMethod]] = None,
-        union_with_default_methods: bool = True) -> None:
+        union_with_default_methods: bool = True,
+        monocle_exporters_list:str = None) -> None:
     """
     Set up Monocle telemetry for the application.
 
@@ -165,7 +178,7 @@ def setup_monocle_telemetry(
         The name of the workflow to be used as the service name in telemetry.
     span_processors : List[SpanProcessor], optional
         Custom span processors to use instead of the default ones. If None, 
-        BatchSpanProcessors with Monocle exporters will be used.
+        BatchSpanProcessors with Monocle exporters will be used. This can't be combined with `monocle_exporters_list`.
     span_handlers : Dict[str, SpanHandler], optional
         Dictionary of span handlers to be used by the instrumentor, mapping handler names to handler objects.
     wrapper_methods : List[Union[dict, WrapperMethod]], optional
@@ -173,11 +186,16 @@ def setup_monocle_telemetry(
     union_with_default_methods : bool, default=True
         If True, combine the provided wrapper_methods with the default methods.
         If False, only use the provided wrapper_methods.
+    monocle_exporters_list : str, optional
+        Comma-separated list of exporters to use. This will override the env setting MONOCLE_EXPORTERS.
+        Supported exporters are: s3, blob, okahu, file, memory, console. This can't be combined with `span_processors`.
     """
     resource = Resource(attributes={
         SERVICE_NAME: workflow_name
     })
-    exporters = get_monocle_exporter()
+    if span_processors and monocle_exporters_list:
+        raise ValueError("span_processors and monocle_exporters_list can't be used together")
+    exporters:List[SpanExporter] = get_monocle_exporter(monocle_exporters_list)
     span_processors = span_processors or [BatchSpanProcessor(exporter) for exporter in exporters]
     set_tracer_provider(TracerProvider(resource=resource))
     attach(set_value("workflow_name", workflow_name))
@@ -192,7 +210,7 @@ def setup_monocle_telemetry(
             get_tracer_provider().add_span_processor(processor)
     if is_proxy_provider:
         trace.set_tracer_provider(get_tracer_provider())
-    instrumentor = MonocleInstrumentor(user_wrapper_methods=wrapper_methods or [], 
+    instrumentor = MonocleInstrumentor(user_wrapper_methods=wrapper_methods or [], exporters=exporters,
                                        handlers=span_handlers, union_with_default_methods = union_with_default_methods)
     # instrumentor.app_name = workflow_name
     if not instrumentor.is_instrumented_by_opentelemetry:
@@ -228,10 +246,10 @@ def start_trace():
         updated_span_context = set_span_in_context(span=span)
         SpanHandler.set_default_monocle_attributes(span)
         SpanHandler.set_workflow_properties(span)
-        token = SpanHandler.attach_workflow_type(context=updated_span_context)
+        token = attach(updated_span_context)
         return token
-    except:
-        logger.warning("Failed to start trace")
+    except Exception as e:
+        logger.warning("Failed to start trace {e}")
         return None
 
 def stop_trace(token) -> None:
@@ -250,7 +268,7 @@ def stop_trace(token) -> None:
             if parent_span is not None:
                 parent_span.end()
         if token is not None:
-            SpanHandler.detach_workflow_type(token)
+            detach(token)
     except:
         logger.warning("Failed to stop trace")
 
@@ -317,8 +335,12 @@ def monocle_trace_scope_method(scope_name: str, scope_value:str=None):
         if inspect.iscoroutinefunction(func):
             @wraps(func)
             async def wrapper(*args, **kwargs):
-                result = async_wrapper(func, scope_name, scope_value, None, *args, **kwargs)
-                return result
+                token = start_scope(scope_name, scope_value)
+                try:
+                    result = await func(*args, **kwargs)
+                    return result
+                finally:
+                    stop_scope(token)
             return wrapper
         else:
             @wraps(func)