monocle-apptrace 0.4.1__tar.gz → 0.4.2__tar.gz

{monocle_apptrace-0.4.1 → monocle_apptrace-0.4.2}/CHANGELOG.md

@@ -1,3 +1,8 @@
+
+## Version 0.4.2 (2025-06-26)
+
+- Add gemini instrumentation ([#220](https://github.com/monocle2ai/monocle/pull/220))
+
 ## Version 0.4.1 (2025-06-17)
 
 - Add exception status code for Boto3 ([#211](https://github.com/monocle2ai/monocle/pull/211))

{monocle_apptrace-0.4.1 → monocle_apptrace-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monocle_apptrace
-Version: 0.4.1
+Version: 0.4.2
 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.4.1 → monocle_apptrace-0.4.2}/pyproject.toml

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

{monocle_apptrace-0.4.1 → monocle_apptrace-0.4.2}/src/monocle_apptrace/instrumentation/common/wrapper_method.py

@@ -23,6 +23,7 @@ from monocle_apptrace.instrumentation.metamodel.aiohttp.methods import (AIOHTTP_
 from monocle_apptrace.instrumentation.metamodel.aiohttp._helper import aiohttpSpanHandler
 from monocle_apptrace.instrumentation.metamodel.azfunc._helper import (azureSpanHandler)
 from monocle_apptrace.instrumentation.metamodel.azfunc.methods import AZFUNC_HTTP_METHODS
+from monocle_apptrace.instrumentation.metamodel.gemini.methods import GEMINI_METHODS
 class WrapperMethod:
     def __init__(
             self,
@@ -71,7 +72,7 @@ class WrapperMethod:
     def get_span_handler(self) -> SpanHandler:
         return self.span_handler()
 
-DEFAULT_METHODS_LIST = LANGCHAIN_METHODS + LLAMAINDEX_METHODS + HAYSTACK_METHODS + BOTOCORE_METHODS + FLASK_METHODS + REQUESTS_METHODS + LANGGRAPH_METHODS + OPENAI_METHODS + TEAMAI_METHODS + ANTHROPIC_METHODS + AIOHTTP_METHODS + AZURE_AI_INFERENCE_METHODS + AZFUNC_HTTP_METHODS
+DEFAULT_METHODS_LIST = LANGCHAIN_METHODS + LLAMAINDEX_METHODS + HAYSTACK_METHODS + BOTOCORE_METHODS + FLASK_METHODS + REQUESTS_METHODS + LANGGRAPH_METHODS + OPENAI_METHODS + TEAMAI_METHODS + ANTHROPIC_METHODS + AIOHTTP_METHODS + AZURE_AI_INFERENCE_METHODS + AZFUNC_HTTP_METHODS + GEMINI_METHODS
 
 MONOCLE_SPAN_HANDLERS: Dict[str, SpanHandler] = {
     "default": SpanHandler(),

monocle_apptrace-0.4.2/src/monocle_apptrace/instrumentation/metamodel/gemini/_helper.py

@@ -0,0 +1,76 @@
+import logging
+from monocle_apptrace.instrumentation.common.utils import (
+    get_exception_message,
+    get_status_code,
+)
+
+logger = logging.getLogger(__name__)
+
+def resolve_from_alias(my_map, alias):
+    """Find a alias that is not none from list of aliases"""
+
+    for i in alias:
+        if i in my_map.keys():
+            return my_map[i]
+    return None
+
+def extract_messages(kwargs):
+    """Extract system and user messages"""
+    try:
+        messages = []
+        config = kwargs.get('config')
+        if config and hasattr(config, 'system_instruction'):
+            system_instructions = getattr(config, 'system_instruction', None)
+            if system_instructions:
+                messages.append({'system': system_instructions})
+
+        contents = kwargs.get('contents')
+        if isinstance(contents, list):
+            for content in contents:
+                if hasattr(content, 'parts') and getattr(content, 'parts'):
+                    part = content.parts[0]
+                    if hasattr(part, 'text'):
+                        messages.append({getattr(content, 'role', 'user'): part.text})
+        elif isinstance(contents, str):
+            messages.append({'input': contents})
+
+        return [str(message) for message in messages]
+    except Exception as e:
+        logger.warning("Warning: Error occurred in extract_messages: %s", str(e))
+        return []
+
+def extract_assistant_message(arguments):
+    try:
+        status = get_status_code(arguments)
+        response: str = ""
+        if status == 'success':
+            if hasattr(arguments['result'], "text") and len(arguments['result'].text):
+                response = arguments['result'].text
+        else:
+            if arguments["exception"] is not None:
+                response = get_exception_message(arguments)
+            elif hasattr(arguments["result"], "error"):
+                response = arguments["result"].error
+        return response
+    except (IndexError, AttributeError) as e:
+        logger.warning("Warning: Error occurred in extract_assistant_message: %s", str(e))
+        return None
+
+def extract_inference_endpoint(instance):
+    try:
+        if hasattr(instance,'_api_client') and hasattr(instance._api_client, '_http_options'):
+            if hasattr(instance._api_client._http_options,'base_url'):
+                return instance._api_client._http_options.base_url
+    except Exception as e:
+        logger.warning("Warning: Error occurred in inference endpoint: %s", str(e))
+        return []
+
+def update_span_from_llm_response(response, instance):
+    meta_dict = {}
+    if response is not None and hasattr(response, "usage_metadata") and response.usage_metadata is not None:
+        token_usage = response.usage_metadata
+        if token_usage is not None:
+            meta_dict.update({"completion_tokens": token_usage.candidates_token_count})
+            meta_dict.update({"prompt_tokens": token_usage.prompt_token_count })
+            meta_dict.update({"total_tokens": token_usage.total_token_count})
+    return meta_dict

monocle_apptrace-0.4.2/src/monocle_apptrace/instrumentation/metamodel/gemini/entities/inference.py

@@ -0,0 +1,75 @@
+from monocle_apptrace.instrumentation.metamodel.gemini import (
+    _helper,
+)
+from monocle_apptrace.instrumentation.common.utils import get_llm_type, get_status, get_status_code
+INFERENCE = {
+    "type": "inference",
+    "attributes": [
+        [
+            {
+                "_comment": "provider type  , inference_endpoint",
+                "attribute": "type",
+                "accessor": lambda arguments: 'inference.gemini'
+            },
+            {
+                "attribute": "inference_endpoint",
+                "accessor": lambda arguments: _helper.extract_inference_endpoint(arguments['instance'])
+            }
+        ],
+        [
+            {
+                "_comment": "LLM Model",
+                "attribute": "name",
+                "accessor": lambda arguments: _helper.resolve_from_alias(arguments['kwargs'],
+                                                                         ['model'])
+            },
+            {
+                "attribute": "type",
+                "accessor": lambda arguments: 'model.llm.' + _helper.resolve_from_alias(arguments['kwargs'],
+                                                                                        ['model'])
+            }
+        ]
+    ],
+    "events": [
+        {
+         "name": "data.input",
+         "attributes": [
+
+             {
+                 "_comment": "this is instruction and user query to LLM",
+                 "attribute": "input",
+                 "accessor": lambda arguments: _helper.extract_messages(arguments['kwargs'])
+             }
+         ]
+         },
+        {
+            "name": "data.output",
+            "attributes": [
+                {
+                    "_comment": "this is result from LLM",
+                    "attribute": "status",
+                    "accessor": lambda arguments: get_status(arguments)
+                },
+                {
+                    "attribute": "status_code",
+                    "accessor": lambda arguments: get_status_code(arguments)
+                },
+                {
+                    "attribute": "response",
+                    "accessor": lambda arguments: _helper.extract_assistant_message(arguments)
+                }
+            ]
+        },
+        {
+            "name": "metadata",
+            "attributes": [
+                {
+                    "_comment": "this is metadata usage from LLM",
+                    "accessor": lambda arguments: _helper.update_span_from_llm_response(arguments['result'], arguments['instance'])
+                }
+            ]
+        }
+
+
+    ]
+}

monocle_apptrace-0.4.2/src/monocle_apptrace/instrumentation/metamodel/gemini/methods.py

@@ -0,0 +1,14 @@
+from monocle_apptrace.instrumentation.common.wrapper import task_wrapper
+from monocle_apptrace.instrumentation.metamodel.gemini.entities.inference import (
+    INFERENCE,
+)
+
+GEMINI_METHODS = [
+    {
+      "package": "google.genai.models",
+      "object": "Models",
+      "method": "generate_content",
+      "wrapper_method": task_wrapper,
+      "output_processor": INFERENCE,
+    }
+]