monocle-apptrace 0.3.1b1__py3-none-any.whl → 0.4.0b1__py3-none-any.whl

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/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/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/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/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/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/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/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/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)

monocle_apptrace/instrumentation/common/span_handler.py

@@ -1,6 +1,6 @@
 import logging
 import os
-from importlib.metadata import version
+from contextlib import contextmanager
 from opentelemetry.context import get_value, set_value, attach, detach
 from opentelemetry.sdk.trace import Span
 from opentelemetry.trace.status import Status, StatusCode
@@ -8,9 +8,9 @@ from monocle_apptrace.instrumentation.common.constants import (
     QUERY,
     service_name_map,
     service_type_map,
-    MONOCLE_SDK_VERSION
+    MONOCLE_SDK_VERSION, MONOCLE_SDK_LANGUAGE, MONOCLE_DETECTED_SPAN_ERROR
 )
-from monocle_apptrace.instrumentation.common.utils import set_attribute, get_scopes, MonocleSpanException
+from monocle_apptrace.instrumentation.common.utils import set_attribute, get_scopes, MonocleSpanException, get_monocle_version
 from monocle_apptrace.instrumentation.common.constants import WORKFLOW_TYPE_KEY, WORKFLOW_TYPE_GENERIC
 
 logger = logging.getLogger(__name__)
@@ -18,7 +18,8 @@ logger = logging.getLogger(__name__)
 WORKFLOW_TYPE_MAP = {
     "llama_index": "workflow.llamaindex",
     "langchain": "workflow.langchain",
-    "haystack": "workflow.haystack"
+    "haystack": "workflow.haystack",
+    "teams.ai": "workflow.teams_ai",
 }
 
 class SpanHandler:
@@ -39,9 +40,9 @@ class SpanHandler:
         pass
 
     def skip_span(self, to_wrap, wrapped, instance, args, kwargs) -> bool:
-        # If this is a workflow span type and a workflow span is already generated, then skip generating this span
-        if to_wrap.get('span_type') == "workflow" and self.is_workflow_span_active():
-            return True
+        return False
+
+    def skip_processor(self, to_wrap, wrapped, instance, args, kwargs) -> bool:
         return False
 
     def pre_task_processing(self, to_wrap, wrapped, instance, args,kwargs, span):
@@ -49,13 +50,11 @@ class SpanHandler:
             set_attribute(QUERY, args[0]['prompt_builder']['question'])
 
     @staticmethod
-    def set_default_monocle_attributes(span: Span):
+    def set_default_monocle_attributes(span: Span, source_path = "" ):
         """ Set default monocle attributes for all spans """
-        try:
-            sdk_version = version("monocle_apptrace")
-            span.set_attribute(MONOCLE_SDK_VERSION, sdk_version)
-        except Exception as e:
-            logger.warning("Exception finding monocle-apptrace version.")
+        span.set_attribute(MONOCLE_SDK_VERSION, get_monocle_version())
+        span.set_attribute(MONOCLE_SDK_LANGUAGE, "python")
+        span.set_attribute("span_source", source_path)
         for scope_key, scope_value in get_scopes().items():
             span.set_attribute(f"scope.{scope_key}", scope_value)
 
@@ -64,25 +63,33 @@ class SpanHandler:
         """ Set attributes of workflow if this is a root span"""
         SpanHandler.set_workflow_attributes(to_wrap, span)
         SpanHandler.set_app_hosting_identifier_attribute(span)
-        span.set_status(StatusCode.OK)
 
+    @staticmethod
+    def set_non_workflow_properties(span: Span, to_wrap = None):
+        workflow_name = SpanHandler.get_workflow_name(span=span)
+        if workflow_name:
+            span.set_attribute("workflow.name", workflow_name)
 
     def post_task_processing(self, to_wrap, wrapped, instance, args, kwargs, result, span:Span):
         if span.status.status_code == StatusCode.UNSET:
             span.set_status(StatusCode.OK)
 
-    def hydrate_span(self, to_wrap, wrapped, instance, args, kwargs, result, span):
-        self.hydrate_attributes(to_wrap, wrapped, instance, args, kwargs, result, span)
-        self.hydrate_events(to_wrap, wrapped, instance, args, kwargs, result, span)
+    def hydrate_span(self, to_wrap, wrapped, instance, args, kwargs, result, span) -> bool:
+        detected_error_in_attribute = self.hydrate_attributes(to_wrap, wrapped, instance, args, kwargs, result, span)
+        detected_error_in_event = self.hydrate_events(to_wrap, wrapped, instance, args, kwargs, result, span)
+        if detected_error_in_attribute or detected_error_in_event:
+            span.set_attribute(MONOCLE_DETECTED_SPAN_ERROR, True)
 
-    def hydrate_attributes(self, to_wrap, wrapped, instance, args, kwargs, result, span):
+    def hydrate_attributes(self, to_wrap, wrapped, instance, args, kwargs, result, span:Span) -> bool:
+        detected_error:bool = False
         span_index = 0
         if SpanHandler.is_root_span(span):
             span_index = 2 # root span will have workflow and hosting entities pre-populated
-        if 'output_processor' in to_wrap and to_wrap["output_processor"] is not None:    
+        if not self.skip_processor(to_wrap, wrapped, instance, args, kwargs) and (
+                'output_processor' in to_wrap and to_wrap["output_processor"] is not None):
             output_processor=to_wrap['output_processor']
             if 'type' in output_processor:
-                        span.set_attribute("span.type", output_processor['type'])
+                span.set_attribute("span.type", output_processor['type'])
             else:
                 logger.warning("type of span not found or incorrect written in entity json")
             if 'attributes' in output_processor:
@@ -100,6 +107,7 @@ class SpanHandler:
                                     span.set_attribute(attribute_name, result)
                             except MonocleSpanException as e:
                                 span.set_status(StatusCode.ERROR, e.message)
+                                detected_error = True
                             except Exception as e:
                                 logger.debug(f"Error processing accessor: {e}")
                         else:
@@ -107,6 +115,8 @@ class SpanHandler:
                     span_index += 1
             else:
                 logger.debug("attributes not found or incorrect written in entity json")
+        else:
+            span.set_attribute("span.type", "generic")
 
         # set scopes as attributes by calling get_scopes()
         # scopes is a Mapping[str:object], iterate directly with .items()
@@ -115,12 +125,14 @@ class SpanHandler:
         
         if span_index > 0:
             span.set_attribute("entity.count", span_index)
+        return detected_error
 
-
-    def hydrate_events(self, to_wrap, wrapped, instance, args, kwargs, result, span):
-        if 'output_processor' in to_wrap and to_wrap["output_processor"] is not None:
+    def hydrate_events(self, to_wrap, wrapped, instance, args, kwargs, ret_result, span) -> bool:
+        detected_error:bool = False
+        if not self.skip_processor(to_wrap, wrapped, instance, args, kwargs) and (
+                'output_processor' in to_wrap and to_wrap["output_processor"] is not None):
             output_processor=to_wrap['output_processor']
-            arguments = {"instance": instance, "args": args, "kwargs": kwargs, "result": result}
+            arguments = {"instance": instance, "args": args, "kwargs": kwargs, "result": ret_result}
             if 'events' in output_processor:
                 events = output_processor['events']
                 for event in events:
@@ -132,21 +144,32 @@ class SpanHandler:
                         accessor = attribute.get("accessor")
                         if accessor:
                             try:
-                                if attribute_key is not None:
-                                    event_attributes[attribute_key] = accessor(arguments)
-                                else:
-                                    event_attributes.update(accessor(arguments))
+                                result = accessor(arguments)
+                                if result and isinstance(result, dict):
+                                    result = dict((key, value) for key, value in result.items() if value is not None)
+                                if result and isinstance(result, (str, list, dict)):
+                                    if attribute_key is not None:
+                                        event_attributes[attribute_key] = result
+                                    else:
+                                        event_attributes.update(result)
                             except MonocleSpanException as e:
                                 span.set_status(StatusCode.ERROR, e.message)
+                                detected_error = True
                             except Exception as e:
                                 logger.debug(f"Error evaluating accessor for attribute '{attribute_key}': {e}")
-                    span.add_event(name=event_name, attributes=event_attributes)
+                    matching_timestamp = getattr(ret_result, "timestamps", {}).get(event_name, None)
+                    if isinstance(matching_timestamp, int):
+                        span.add_event(name=event_name, attributes=event_attributes, timestamp=matching_timestamp)
+                    else:
+                        span.add_event(name=event_name, attributes=event_attributes)
+        return detected_error
 
     @staticmethod
     def set_workflow_attributes(to_wrap, span: Span):
         span_index = 1
         workflow_name = SpanHandler.get_workflow_name(span=span)
         if workflow_name:
+            span.update_name("workflow")
             span.set_attribute("span.type", "workflow")
             span.set_attribute(f"entity.{span_index}.name", workflow_name)
         workflow_type = SpanHandler.get_workflow_type(to_wrap)
@@ -186,26 +209,19 @@ class SpanHandler:
     @staticmethod
     def is_root_span(curr_span: Span) -> bool:
         try:
-            if curr_span is not None and hasattr(curr_span, "parent"):
+            if curr_span is not None and hasattr(curr_span, "parent") or  curr_span.context.trace_state:
                 return curr_span.parent is None
         except Exception as e:
             logger.warning(f"Error finding root span: {e}")
 
-    def is_non_workflow_root_span(self, curr_span: Span, to_wrap) -> bool:
-        return SpanHandler.is_root_span(curr_span) and to_wrap.get("span_type") != "workflow"
-    
-    def is_workflow_span_active(self):
-        return get_value(WORKFLOW_TYPE_KEY) is not None
-
     @staticmethod
     def attach_workflow_type(to_wrap=None, context=None): 
         token = None
         if to_wrap:
-            if to_wrap.get('span_type') == "workflow":
+            workflow_type = SpanHandler.get_workflow_type(to_wrap)
+            if workflow_type != WORKFLOW_TYPE_GENERIC:
                 token = attach(set_value(WORKFLOW_TYPE_KEY,
                                         SpanHandler.get_workflow_type(to_wrap), context))
-        else:
-            token = attach(set_value(WORKFLOW_TYPE_KEY, WORKFLOW_TYPE_GENERIC, context))
         return token
 
     @staticmethod
@@ -213,8 +229,18 @@ class SpanHandler:
         if token:
             return detach(token)
 
+    @staticmethod
+    @contextmanager
+    def workflow_type(to_wrap=None):
+        token = SpanHandler.attach_workflow_type(to_wrap)
+        try:
+            yield
+        finally:
+            SpanHandler.detach_workflow_type(token)
+
+
 class NonFrameworkSpanHandler(SpanHandler):
 
-    # If the language framework is being executed, then skip generating direct openAI spans
-    def skip_span(self, to_wrap, wrapped, instance, args, kwargs) -> bool:
+    # If the language framework is being executed, then skip generating direct openAI attributes and events
+    def skip_processor(self, to_wrap, wrapped, instance, args, kwargs) -> bool:
         return get_value(WORKFLOW_TYPE_KEY) in WORKFLOW_TYPE_MAP.values()