Remove deployment arg

Author: dmelikyan

README.md

@@ -8,7 +8,7 @@ Graphsignal is an AI optimization platform, enabling developers to achieve faste
 
 * Identify and optimize the most significant contributors to latency.
 * Analyze model API costs for deployments, models, sessions, or any custom tags.
-* Ensure optimal model configuration and inference performance for hosted models.
+* Ensure optimal inference performance and model configuration for hosted models.
 * Track errors and monitor APIs, compute, and GPU utilization.
 
 
@@ -33,9 +33,13 @@ Configure Graphsignal tracer by specifying your API key directly or via `GRAPHSI
 ```python
 import graphsignal
 
-graphsignal.configure(api_key='my-api-key', deployment='my-app')
+graphsignal.configure(api_key='my-api-key')
+# or pass the API key in GRAPHSIGNAL_API_KEY environment variable
 ```
 
+See [`configure()`](https://graphsignal.com/docs/reference/python-api/#graphsignalconfigure) API docs for all configuration parameters.
+
+
 To get an API key, sign up for a free account at [graphsignal.com](https://graphsignal.com). The key can then be found in your account's [Settings / API Keys](https://app.graphsignal.com/settings/api-keys) page.
 
 Alternatively, you can add Graphsignal tracer from the command line, when running your module or script. Environment variables `GRAPHSIGNAL_API_KEY` and `GRAPHSIGNAL_DEPLOYMENT` must be set.

graphsignal/__init__.py

@@ -1,15 +1,11 @@
-from typing import Dict, Any, Union, Optional
+from typing import Dict, Any, Union, Optional, Type
 import os
 import logging
 import atexit
-import functools
-import asyncio
-import time
 
 from graphsignal.version import __version__
 from graphsignal.tracer import Tracer
 from graphsignal.spans import Span
-from graphsignal import client
 
 logger = logging.getLogger('graphsignal')
 
@@ -23,66 +19,85 @@ def _check_configured():
             'Tracer not configured, call graphsignal.configure() first')
 
 
-def _check_and_set_arg(
-        name, value, is_str=False, is_int=False, is_bool=False, is_kv=False, required=False, max_len=None):
-    env_name = 'GRAPHSIGNAL_{0}'.format(name.upper())
+def _parse_env_param(name: str, value: Any, expected_type: Type) -> Any:
+    if value is None:
+        return None
 
-    if not value and env_name in os.environ:
-        value = os.environ[env_name]
-        if value:
-            if is_str:
-                if max_len and len(value) > max_len:
-                    raise ValueError('configure: invalid format, expected string with max length {0}: {1}'.format(max_len, name))
-            if is_int:
-                try:
-                    value = int(value)
-                except:
-                    raise ValueError('configure: invalid format, expected integer: {0}'.format(name))
-            elif is_bool:
-                value = bool(value)
-            elif is_kv:
-                try:
-                    value = dict([el.strip(' ') for el in kv.split('=')] for kv in value.split(','))
-                except:
-                    raise ValueError('configure: invalid format, expected comma-separated key-value list (k1=v1,k2=v2): {0}'.format(name))
+    try:
+        if expected_type == bool:
+            return value if isinstance(value, bool) else str(value).lower() in ("true", "1", "yes")
+        elif expected_type == int:
+            return int(value)
+        elif expected_type == float:
+            return float(value)
+        elif expected_type == str:
+            return str(value)
+    except (ValueError, TypeError):
+        pass
 
-    if not value and required:
-        raise ValueError('configure: missing argument: {0}'.format(name))
+    raise ValueError(f"Invalid type for {name}: expected {expected_type.__name__}, got {type(value).__name__}")
 
-    return value
+
+def _read_config_param(name: str, expected_type: Type, provided_value: Optional[Any] = None, required: bool = False) -> Any:
+    # Check if the value was provided as an argument
+    if provided_value is not None:
+        return provided_value
+
+    # Check if the value was provided as an environment variable
+    env_value = os.getenv(f'GRAPHSIGNAL_{name.upper()}')
+    if env_value is None:
+        if required:
+            raise ValueError(f"Missing required argument: {name}")
+        return None
+
+    # Parse the environment variable
+    return _parse_env_param(name, env_value, expected_type)
+
+
+def _read_config_tags(provided_value: Optional[dict] = None, prefix: str = "GRAPHSIGNAL_TAG_") -> Dict[str, str]:
+    # Check if the value was provided as an argument
+    if provided_value is not None:
+        return provided_value
+
+    # Check if the value was provided as an environment variable
+    return {key[len(prefix):].lower(): value for key, value in os.environ.items() if key.startswith(prefix)}
 
 
 def configure(
-        api_key: Optional[str] = None,
-        api_url: Optional[str] = None,
-        deployment: Optional[str] = None,
-        tags: Optional[Dict[str, str]] = None,
-        auto_instrument: Optional[bool] = True,
-        record_payloads: Optional[bool] = True,
-        profiling_rate: Optional[float] = 0.1,
-        upload_on_shutdown: Optional[bool] = True,
-        debug_mode: Optional[bool] = False) -> None:
+    api_key: Optional[str] = None,
+    api_url: Optional[str] = None,
+    deployment: Optional[str] = None,
+    tags: Optional[Dict[str, str]] = None,
+    auto_instrument: Optional[bool] = True,
+    record_payloads: Optional[bool] = True,
+    profiling_rate: Optional[float] = 0.1,
+    debug_mode: Optional[bool] = False
+) -> None:
     global _tracer
 
     if _tracer:
-        logger.warning('Tracer already configured')
+        logger.warning("Tracer already configured")
         return
 
-    debug_mode = _check_and_set_arg('debug_mode', debug_mode, is_bool=True)
-    api_key = _check_and_set_arg('api_key', api_key, is_str=True, required=True)
-    api_url = _check_and_set_arg('api_url', api_url, is_str=True, required=False)
-    deployment = _check_and_set_arg('deployment', deployment, is_str=True, required=True)
-    tags = _check_and_set_arg('tags', tags, is_kv=True, required=False)
+    api_key = _read_config_param("api_key", str, api_key, required=True)
+    api_url = _read_config_param("api_url", str, api_url)
+    tags = _read_config_tags(tags)
+    auto_instrument = _read_config_param("auto_instrument", bool, auto_instrument)
+    record_payloads = _read_config_param("record_payloads", bool, record_payloads)
+    profiling_rate = _read_config_param("profiling_rate", float, profiling_rate)
+    debug_mode = _read_config_param("debug_mode", bool, debug_mode)
+
+    # left for compatibility
+    if deployment and isinstance(deployment, str):
+        tags['deployment'] = deployment
 
     _tracer = Tracer(
         api_key=api_key,
         api_url=api_url,
-        deployment=deployment,
         tags=tags,
         auto_instrument=auto_instrument,
         record_payloads=record_payloads,
         profiling_rate=profiling_rate,
-        upload_on_shutdown=upload_on_shutdown,
         debug_mode=debug_mode)
     _tracer.setup()
 

graphsignal/recorders/openai_recorder.py

@@ -183,9 +183,10 @@ def trace_chat_completion(self, span, args, kwargs, ret, exc):
         self.set_common_tags(span, 'chat/completions', params)
         if 'model' in params:
             span.set_tag('model', params['model'])
-
         if 'reasoning_effort' in params:
             span.set_tag('reasoning_effort', params['reasoning_effort'])
+        if 'max_completion_tokens' in params:
+            span.set_tag('max_completion_tokens', params['max_completion_tokens'])
 
         if 'stream' in params and params['stream']:
             if 'messages' in params:

graphsignal/tracer.py

@@ -113,12 +113,10 @@ def __init__(
             self, 
             api_key=None, 
             api_url=None, 
-            deployment=None, 
             tags=None, 
             auto_instrument=True, 
             record_payloads=True, 
             profiling_rate=0.1,
-            upload_on_shutdown=True, 
             debug_mode=False):
         if debug_mode:
             logger.setLevel(logging.DEBUG)
@@ -127,24 +125,19 @@ def __init__(
 
         if not api_key:
             raise ValueError('api_key is required')
-        if not deployment:
-            raise ValueError('deployment is required')
 
         self.api_key = api_key
         if api_url:
             self.api_url = api_url
         else:
             self.api_url = 'https://api.graphsignal.com'
-        self.deployment = deployment
-        self.tags = dict(deployment=self.deployment)
-        if tags:
-            self.tags.update(tags)
+        self.tags = {}
+        self.tags.update(tags)
         self.context_tags = contextvars.ContextVar('graphsignal_context_tags', default={})
 
         self.auto_instrument = auto_instrument
         self.record_payloads = record_payloads
         self.profiling_rate = profiling_rate if profiling_rate is not None else 0
-        self.upload_on_shutdown = upload_on_shutdown
         self.debug_mode = debug_mode
 
         self._metric_update_thread = None
@@ -160,6 +153,8 @@ def __init__(
         self.last_metric_upload_ts = int(self._process_start_ms / 1e3)
         self.last_log_upload_ts = int(self._process_start_ms / 1e3)
 
+        self.export_on_shutdown = True
+
     def setup(self):
         self._uploader = Uploader()
         self._uploader.setup()
@@ -185,7 +180,7 @@ def shutdown(self):
             self._metric_update_thread.join()
             self._metric_update_thread = None
 
-        if self.upload_on_shutdown:
+        if self.export_on_shutdown:
             if self._metric_store.has_unexported():
                 metrics = self._metric_store.export()
                 for metric in metrics:

graphsignal/version.py

@@ -1 +1 @@
-__version__ = '0.16.1'
+__version__ = '0.16.2'