hyperprobe-agent 1.2.26b3__tar.gz → 1.2.27__tar.gz

{hyperprobe_agent-1.2.26b3 → hyperprobe_agent-1.2.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperprobe-agent
-Version: 1.2.26b3
+Version: 1.2.27
 Summary: Production-grade, non-breaking live debugger and telemetry agent for Python.
 Home-page: https://www.hyperprobe.co
 Author: Arif, Saksham, Karan
@@ -98,7 +98,8 @@ Configure the agent using the following environment variables:
 | Variable | Description | Default |
 | --- | --- | --- |
 | `HYPERPROBE_BROKER_URL` | The URL of the HyperProbe Telemetry Broker. | *Required* |
-| `HYPERPROBE_SERVICE_ID` | A unique name identifying this service. | *Required* |
+| `HYPERPROBE_SERVICE_ID` | UUIDv4 service identifier provided by the HyperProbe dashboard. | *Required* |
+| `HYPERPROBE_ALLOW_NON_UUID` | Set to `yes` only to allow a legacy non-UUID service identifier. | *(unset)* |
 | `HYPERPROBE_ENVIRONMENT` | Deployment environment name (e.g., `production`, `staging`). | *Required* |
 | `HYPERPROBE_COMMIT_SHA` or `GIT_COMMIT` | Git commit SHA of the running application version. | *Required* |
 | `HYPERPROBE_DISABLED` | Set to `YES` to explicitly disable the agent. | *(unset)* |
@@ -109,7 +110,7 @@ Configure the agent using the following environment variables:
 | `HYPERPROBE_BANDWIDTH_KB_PER_SEC` | Max bandwidth limit for telemetry transmissions (quota). | `1024` (1 MB) |
 | `HYPERPROBE_RPC_TIMEOUT_SEC` | Deadline for broker RPCs. | `10` |
 | `HYPERPROBE_COOLDOWN_SEC` | Tracing suspension duration after a RED safety state. | `10` |
-| `HYPERPROBE_MAX_LAG_MS` | Execution-thread lag threshold for the safety monitor. | `50` |
+| `HYPERPROBE_MAX_LAG_MS` | Per-reading scheduler-lag threshold. YELLOW requires 4/10 breaches; RED requires 7/10 breaches or 3/5 readings above 4x the threshold. | `50` |
 | `HYPERPROBE_PAUSE_BUDGET_MS` | Per-second capture pause budget for the safety monitor. | `15` |
 | `HYPERPROBE_REDACT_KEYS` | Comma-separated key patterns to redact. | `password,secret,token,authorization,cookie,key,signature` |
 | `HYPERPROBE_REDACT_VALUES` | Comma-separated value patterns to redact. | *(empty)* |
@@ -118,8 +119,22 @@ Configure the agent using the following environment variables:
 | `HYPERPROBE_STACK_FRAME_DEPTH` | Maximum captured stack-frame depth. | `3` |
 | `HYPERPROBE_MAX_OBJECT_PROPERTIES` | Maximum serialized properties per object. | `50` |
 | `HYPERPROBE_MAX_STRING_LENGTH` | Maximum serialized string length. | `1024` |
+| `HYPERPROBE_DISABLE_SAFE_EVALUATION` | Set to `true` to explicitly disable safe evaluation restrictions and allow arbitrary method/function calls in probe expressions. | `false` |
 | `HYPERPROBE_FORK_MODE` | Set to `worker` for preloaded, prefork servers. The parent defers agent initialization and every worker starts fresh process-local state. | `none` |
 
+Programmatic integrations can set `allow_non_uuid=True` for the same legacy
+bypass. Without an explicit bypass, a non-UUIDv4 service ID prevents agent
+startup while the host application continues normally.
+
+### Safe Evaluation & Security Considerations
+
+By default, **safe evaluation is enabled** (`HYPERPROBE_DISABLE_SAFE_EVALUATION=false`). In safe mode:
+- Method and function calls are strictly restricted to a narrow allowlist of side-effect free standard operations.
+- State mutations, assignments, and arbitrary function invocations (such as database calls, network I/O, file operations, or state modifications) are prevented.
+
+**Disabling Safe Evaluation (`HYPERPROBE_DISABLE_SAFE_EVALUATION=true`):**
+> ⚠️ **Security Warning**: Setting `HYPERPROBE_DISABLE_SAFE_EVALUATION=true` allows conditions, watch expressions, and log templates to execute arbitrary functions and methods in the host application process. This may lead to unintended side effects, state mutations, performance degradation, or security risks if expressions invoke mutating or blocking operations. Only disable safe evaluation in trusted environments where dynamic method evaluation is strictly required.
+
 ### Debug logging
 
 Set `DEBUG` to a comma- or space-separated list of namespaces. Patterns accept

{hyperprobe_agent-1.2.26b3 → hyperprobe_agent-1.2.27}/README.md

@@ -63,7 +63,8 @@ Configure the agent using the following environment variables:
 | Variable | Description | Default |
 | --- | --- | --- |
 | `HYPERPROBE_BROKER_URL` | The URL of the HyperProbe Telemetry Broker. | *Required* |
-| `HYPERPROBE_SERVICE_ID` | A unique name identifying this service. | *Required* |
+| `HYPERPROBE_SERVICE_ID` | UUIDv4 service identifier provided by the HyperProbe dashboard. | *Required* |
+| `HYPERPROBE_ALLOW_NON_UUID` | Set to `yes` only to allow a legacy non-UUID service identifier. | *(unset)* |
 | `HYPERPROBE_ENVIRONMENT` | Deployment environment name (e.g., `production`, `staging`). | *Required* |
 | `HYPERPROBE_COMMIT_SHA` or `GIT_COMMIT` | Git commit SHA of the running application version. | *Required* |
 | `HYPERPROBE_DISABLED` | Set to `YES` to explicitly disable the agent. | *(unset)* |
@@ -74,7 +75,7 @@ Configure the agent using the following environment variables:
 | `HYPERPROBE_BANDWIDTH_KB_PER_SEC` | Max bandwidth limit for telemetry transmissions (quota). | `1024` (1 MB) |
 | `HYPERPROBE_RPC_TIMEOUT_SEC` | Deadline for broker RPCs. | `10` |
 | `HYPERPROBE_COOLDOWN_SEC` | Tracing suspension duration after a RED safety state. | `10` |
-| `HYPERPROBE_MAX_LAG_MS` | Execution-thread lag threshold for the safety monitor. | `50` |
+| `HYPERPROBE_MAX_LAG_MS` | Per-reading scheduler-lag threshold. YELLOW requires 4/10 breaches; RED requires 7/10 breaches or 3/5 readings above 4x the threshold. | `50` |
 | `HYPERPROBE_PAUSE_BUDGET_MS` | Per-second capture pause budget for the safety monitor. | `15` |
 | `HYPERPROBE_REDACT_KEYS` | Comma-separated key patterns to redact. | `password,secret,token,authorization,cookie,key,signature` |
 | `HYPERPROBE_REDACT_VALUES` | Comma-separated value patterns to redact. | *(empty)* |
@@ -83,8 +84,22 @@ Configure the agent using the following environment variables:
 | `HYPERPROBE_STACK_FRAME_DEPTH` | Maximum captured stack-frame depth. | `3` |
 | `HYPERPROBE_MAX_OBJECT_PROPERTIES` | Maximum serialized properties per object. | `50` |
 | `HYPERPROBE_MAX_STRING_LENGTH` | Maximum serialized string length. | `1024` |
+| `HYPERPROBE_DISABLE_SAFE_EVALUATION` | Set to `true` to explicitly disable safe evaluation restrictions and allow arbitrary method/function calls in probe expressions. | `false` |
 | `HYPERPROBE_FORK_MODE` | Set to `worker` for preloaded, prefork servers. The parent defers agent initialization and every worker starts fresh process-local state. | `none` |
 
+Programmatic integrations can set `allow_non_uuid=True` for the same legacy
+bypass. Without an explicit bypass, a non-UUIDv4 service ID prevents agent
+startup while the host application continues normally.
+
+### Safe Evaluation & Security Considerations
+
+By default, **safe evaluation is enabled** (`HYPERPROBE_DISABLE_SAFE_EVALUATION=false`). In safe mode:
+- Method and function calls are strictly restricted to a narrow allowlist of side-effect free standard operations.
+- State mutations, assignments, and arbitrary function invocations (such as database calls, network I/O, file operations, or state modifications) are prevented.
+
+**Disabling Safe Evaluation (`HYPERPROBE_DISABLE_SAFE_EVALUATION=true`):**
+> ⚠️ **Security Warning**: Setting `HYPERPROBE_DISABLE_SAFE_EVALUATION=true` allows conditions, watch expressions, and log templates to execute arbitrary functions and methods in the host application process. This may lead to unintended side effects, state mutations, performance degradation, or security risks if expressions invoke mutating or blocking operations. Only disable safe evaluation in trusted environments where dynamic method evaluation is strictly required.
+
 ### Debug logging
 
 Set `DEBUG` to a comma- or space-separated list of namespaces. Patterns accept

{hyperprobe_agent-1.2.26b3 → hyperprobe_agent-1.2.27}/hyperprobe/agent.py

@@ -78,6 +78,22 @@ class HyperProbeAgent:
         max_lag_ms = options.get("hyperprobe_max_lag_ms") or float(os.getenv("HYPERPROBE_MAX_LAG_MS", 50.0))
         pause_budget_ms = options.get("hyperprobe_pause_budget_ms") or float(os.getenv("HYPERPROBE_PAUSE_BUDGET_MS", 15.0))
 
+        opt_disable_safe_eval = options.get("disable_safe_evaluation", False)
+        disable_safe_eval = (
+            os.getenv("HYPERPROBE_DISABLE_SAFE_EVALUATION", "").strip().lower() == "true"
+            or opt_disable_safe_eval is True
+            or (
+                isinstance(opt_disable_safe_eval, str)
+                and opt_disable_safe_eval.strip().lower() == "true"
+            )
+        )
+
+        if disable_safe_eval:
+            logger.forceInfo(
+                "\033[1m\033[33m⚠️  [HyperProbe] WARN: Safe evaluation is DISABLED via "
+                "HYPERPROBE_DISABLE_SAFE_EVALUATION. Function and method calls are permitted in probe expressions.\033[0m"
+            )
+
         self.global_config = {
             "redact_keys": options.get("redact_keys") or os.getenv("HYPERPROBE_REDACT_KEYS", "password,secret,token,authorization,cookie,key,signature").split(","),
             "redact_values": options.get("redact_values") or os.getenv("HYPERPROBE_REDACT_VALUES", "").split(","),
@@ -85,7 +101,8 @@ class HyperProbeAgent:
             "max_array_length": options.get("max_array_length") or int(os.getenv("HYPERPROBE_MAX_ARRAY_LENGTH", 3)),
             "stack_frame_depth": options.get("stack_frame_depth") or int(os.getenv("HYPERPROBE_STACK_FRAME_DEPTH", 3)),
             "max_object_properties": options.get("max_object_properties") or int(os.getenv("HYPERPROBE_MAX_OBJECT_PROPERTIES", 50)),
-            "max_string_length": options.get("max_string_length") or int(os.getenv("HYPERPROBE_MAX_STRING_LENGTH", 1024))
+            "max_string_length": options.get("max_string_length") or int(os.getenv("HYPERPROBE_MAX_STRING_LENGTH", 1024)),
+            "disable_safe_evaluation": disable_safe_eval,
         }
 
         # Strip empty redaction strings
@@ -108,6 +125,7 @@ class HyperProbeAgent:
             agent_id=self.agent_id,
             rpc_timeout_sec=rpc_timeout_sec,
         )
+        self.agent_version = self.broker_client.agent_version
 
         # Thread-safe queue for telemetry events
         self.telemetry_queue = queue.Queue(maxsize=self.max_queue_size)
@@ -168,7 +186,21 @@ class HyperProbeAgent:
                 logger.forceError('\033[1m\033[33m⚠️  [HyperProbe] CRITICAL: Failed to start agent. HYPERPROBE_SERVICE_ID is required.\033[0m')
                 return None
             if not UUID_REGEX.match(str(service_id).strip()):
-                logger.forceInfo('\033[1m\033[33m⚠️  [HyperProbe] WARN: service_id is not a valid UUID, please check again.\033[0m')
+                allow_non_uuid = options.get("allow_non_uuid")
+                if allow_non_uuid is None:
+                    allow_non_uuid = (
+                        os.getenv("HYPERPROBE_ALLOW_NON_UUID", "")
+                        .strip()
+                        .lower()
+                        == "yes"
+                    )
+                elif isinstance(allow_non_uuid, str):
+                    allow_non_uuid = allow_non_uuid.strip().lower() == "yes"
+
+                if not allow_non_uuid:
+                    logger.forceError('\033[1m\033[33m⚠️  [HyperProbe] CRITICAL: Failed to start agent. service_id is not a valid UUIDv4. Set HYPERPROBE_ALLOW_NON_UUID=yes to allow non-UUID identifiers.\033[0m')
+                    return None
+                logger.forceInfo('\033[1m\033[33m⚠️  [HyperProbe] WARN: service_id is not a valid UUIDv4, please check again.\033[0m')
             options["service_id"] = service_id
 
             environment = options.get("environment") or os.getenv("HYPERPROBE_ENVIRONMENT")
@@ -215,7 +247,8 @@ class HyperProbeAgent:
                 return None
             logger.forceInfo(
                 f"[HyperProbe] Python agent successfully started "
-                f"(ID: {cls._instance.agent_id}, PID: {cls._instance.owner_pid})."
+                f"(Version: {cls._instance.agent_version}, "
+                f"ID: {cls._instance.agent_id}, PID: {cls._instance.owner_pid})."
             )
             return cls._instance
 
@@ -308,7 +341,8 @@ class HyperProbeAgent:
 
         logger.forceInfo(
             f"[HyperProbe] Python agent started after fork "
-            f"(ID: {instance.agent_id}, PID: {instance.owner_pid})."
+            f"(Version: {instance.agent_version}, "
+            f"ID: {instance.agent_id}, PID: {instance.owner_pid})."
         )
 
     @classmethod
@@ -716,7 +750,7 @@ class HyperProbeAgent:
             return
 
         if health == AgentHealth.RED:
-            logger.error(f"[HyperProbe] Safety Shield Triggered (RED): {reason or ''}. Suspending tracing.")
+            logger.error(f"[HyperProbe] Safety Shield Triggered (RED): {reason or ''}. Suspending instrumentation.")
             with self._agent_lock:
                 self.engine.suspend()
 
@@ -739,6 +773,7 @@ class HyperProbeAgent:
             with self._agent_lock:
                 cooldown_expired = self.cooldown_timer is None
             if cooldown_expired:
+                logger.info(f"[HyperProbe] Status back to GREEN. {reason or ''}.")
                 self._resume_instrumentation()
 
     def _cooldown_expired(self, cooldown_generation):
@@ -752,6 +787,7 @@ class HyperProbeAgent:
         with self._agent_lock:
             if (
                 self.is_shutdown
+                or not self.engine.is_suspended
                 or self.safety_monitor.get_health() != AgentHealth.GREEN
                 or self.cooldown_timer is not None
             ):

{hyperprobe_agent-1.2.26b3 → hyperprobe_agent-1.2.27}/hyperprobe/core/evaluator.py

@@ -1,6 +1,8 @@
+import os
 import re
 import ast
 from functools import lru_cache
+from typing import Optional
 
 from hyperprobe.core.logger import get_logger
 
@@ -23,6 +25,9 @@ SAFE_METHODS = {
     "isdigit", "isalpha", "isnumeric", "isalnum",
 }
 
+def is_safe_evaluation_enabled() -> bool:
+    return os.getenv("HYPERPROBE_DISABLE_SAFE_EVALUATION", "").strip().lower() != "true"
+
 class SafeASTVisitor(ast.NodeVisitor):
     def visit_Call(self, node):
         # 1. Is it a direct function call? e.g. len(items)
@@ -46,11 +51,20 @@ class ProbeEvaluator:
     _placeholder_regex = re.compile(r'\$?\{([^}]+)\}')
 
     @classmethod
-    def _get_or_compile_safe(cls, expr: str):
+    def is_safe_evaluation_enabled(cls) -> bool:
+        return is_safe_evaluation_enabled()
+
+    @classmethod
+    def _get_or_compile(cls, expr: str, safe: bool = True):
         # Normalize the string to prevent duplicate cache entries
         clean_expr = expr.strip()
+        if safe:
+            return cls._compile_safe(clean_expr)
+        return cls._compile_unsafe(clean_expr)
 
-        return cls._compile_safe(clean_expr)
+    @classmethod
+    def _get_or_compile_safe(cls, expr: str):
+        return cls._get_or_compile(expr, safe=True)
 
     @staticmethod
     @lru_cache(maxsize=COMPILED_CACHE_SIZE)
@@ -69,24 +83,46 @@ class ProbeEvaluator:
         
         return compiled_code
 
+    @staticmethod
+    @lru_cache(maxsize=COMPILED_CACHE_SIZE)
+    def _compile_unsafe(clean_expr: str):
+        # Unsafe mode allows function/method calls without AST validation
+        return compile(clean_expr, filename="<string>", mode="eval")
+
     @classmethod
-    def safe_eval(cls, expr: str, globals_dict: dict, locals_dict: dict):
-        # Create a shadow copy of globals, forcefully removing dangerous builtins
-        safe_globals = globals_dict.copy()
-        safe_globals["__builtins__"] = SAFE_BUILTINS
+    def evaluate(cls, expr: str, globals_dict: dict, locals_dict: dict, safe: Optional[bool] = None):
+        if safe is None:
+            safe = cls.is_safe_evaluation_enabled()
 
-        # Grab the pre-compiled bytecode instantly
-        compiled = cls._get_or_compile_safe(expr)
-        
-        # Execute the bytecode
-        return eval(compiled, safe_globals, locals_dict)
+        if safe:
+            # Create a shadow copy of globals, forcefully removing dangerous builtins
+            safe_globals = globals_dict.copy()
+            safe_globals["__builtins__"] = SAFE_BUILTINS
+
+            # Grab the pre-compiled safe bytecode
+            compiled = cls._get_or_compile(expr, safe=True)
+            
+            # Execute the bytecode
+            return eval(compiled, safe_globals, locals_dict)
+        else:
+            # Grab the pre-compiled unsafe bytecode allowing full execution
+            compiled = cls._get_or_compile(expr, safe=False)
+            return eval(compiled, globals_dict, locals_dict)
+
+    @classmethod
+    def safe_eval(cls, expr: str, globals_dict: dict, locals_dict: dict, safe: Optional[bool] = None):
+        """Evaluates an expression, delegating to ProbeEvaluator.evaluate."""
+        return cls.evaluate(expr, globals_dict, locals_dict, safe=safe)
 
     @classmethod
-    def evaluate_log_template(cls, template: str, globals_dict: dict, locals_dict: dict) -> str:
-        """Parses and safely formats a log template string."""
+    def evaluate_log_template(cls, template: str, globals_dict: dict, locals_dict: dict, safe: Optional[bool] = None) -> str:
+        """Parses and formats a log template string."""
         if not template:
             return ""
         
+        if safe is None:
+            safe = cls.is_safe_evaluation_enabled()
+
         result = []
         last_idx = 0
         for match in cls._placeholder_regex.finditer(template):
@@ -95,8 +131,8 @@ class ProbeEvaluator:
             expr = match.group(1).strip()
             
             try:
-                # Safely execute expression
-                val = cls.safe_eval(expr, globals_dict, locals_dict)
+                # Execute expression
+                val = cls.evaluate(expr, globals_dict, locals_dict, safe=safe)
                 result.append(str(val))
             except Exception as e:
                 result.append(f"<Error: {type(e).__name__}: {str(e)}>")
@@ -106,14 +142,16 @@ class ProbeEvaluator:
         return "".join(result)
 
     @classmethod
-    def evaluate_watches(cls, watch_expressions: list, globals_dict: dict, locals_dict: dict) -> dict:
+    def evaluate_watches(cls, watch_expressions: list, globals_dict: dict, locals_dict: dict, safe: Optional[bool] = None) -> dict:
         """Evaluates a set of independent watch expressions."""
         results = {}
         if not watch_expressions:
             return results
+        if safe is None:
+            safe = cls.is_safe_evaluation_enabled()
         for expr in watch_expressions:
             try:
-                results[expr] = cls.safe_eval(expr, globals_dict, locals_dict)
+                results[expr] = cls.evaluate(expr, globals_dict, locals_dict, safe=safe)
             except Exception as e:
                 results[expr] = f"Error: {type(e).__name__}: {str(e)}"
         return results

{hyperprobe_agent-1.2.26b3 → hyperprobe_agent-1.2.27}/hyperprobe/core/monitoring_engine.py

@@ -49,6 +49,7 @@ class MonitoringEngine:
         self.instrumented_files = set()
         self.is_active = False
         self.is_suspended = False
+        self.safe_evaluation = ProbeEvaluator.is_safe_evaluation_enabled()
         self.global_config = {}
         self._redact_keys_re = None
         self._redact_values_re = None
@@ -112,8 +113,25 @@ class MonitoringEngine:
             self.global_config = candidate
             self._redact_keys_re = redact_keys_re
             self._redact_values_re = redact_values_re
+            self.safe_evaluation = self._is_safe_evaluation_enabled(candidate)
             return True
 
+    def _is_safe_evaluation_enabled(self, config_snapshot=None) -> bool:
+        """Resolves whether safe evaluation is active from a config snapshot or internal state."""
+        config = config_snapshot if config_snapshot is not None else self.global_config
+        if config:
+            if "disable_safe_evaluation" in config:
+                v = config["disable_safe_evaluation"]
+                if isinstance(v, str):
+                    v = v.strip().lower() == "true"
+                return not bool(v)
+            if "safe_evaluation" in config:
+                v = config["safe_evaluation"]
+                if isinstance(v, str):
+                    v = v.strip().lower() == "true"
+                return bool(v)
+        return self.safe_evaluation
+
     @staticmethod
     def _compile_redaction_patterns(patterns):
         if patterns is None:
@@ -396,10 +414,11 @@ class MonitoringEngine:
             config_snapshot = self.global_config.copy() if self.global_config else {}
             redact_keys_re = self._redact_keys_re
             redact_values_re = self._redact_values_re
+            safe_evaluation = self._is_safe_evaluation_enabled(config_snapshot)
 
         if probe.condition:
             try:
-                cond_val = ProbeEvaluator.safe_eval(probe.condition, globals_dict, locals_dict)
+                cond_val = ProbeEvaluator.evaluate(probe.condition, globals_dict, locals_dict, safe=safe_evaluation)
                 if not cond_val:
                     return
             except Exception as e:
@@ -440,7 +459,7 @@ class MonitoringEngine:
                 serialization_context = {}
 
                 if getattr(probe, 'watch_expressions', None):
-                    watches_result = ProbeEvaluator.evaluate_watches(probe.watch_expressions, globals_dict, locals_dict)
+                    watches_result = ProbeEvaluator.evaluate_watches(probe.watch_expressions, globals_dict, locals_dict, safe=safe_evaluation)
                     serialized_watches = {}
                     for watch_name, watch_value in watches_result.items():
                         watch_path = f"watch[{json.dumps(str(watch_name))}]"
@@ -498,7 +517,7 @@ class MonitoringEngine:
 
             # LOG TEMPLATE CAPTURE
             elif probe.type == 2:
-                evaluated = ProbeEvaluator.evaluate_log_template(probe.template, globals_dict, locals_dict)
+                evaluated = ProbeEvaluator.evaluate_log_template(probe.template, globals_dict, locals_dict, safe=safe_evaluation)
                 if redact_values_re and redact_values_re.search(evaluated):
                     evaluated = redact_values_re.sub("[REDACTED Value]", evaluated)
                 if len(evaluated) > max_string_length:
@@ -529,11 +548,14 @@ class MonitoringEngine:
         globals_dict = frame.f_globals
         locals_dict = frame.f_locals
 
+        with self.lock:
+            safe_evaluation = self._is_safe_evaluation_enabled()
+
         try:
             if probe.condition:
                 try:
-                    if not ProbeEvaluator.safe_eval(
-                        probe.condition, globals_dict, locals_dict
+                    if not ProbeEvaluator.evaluate(
+                        probe.condition, globals_dict, locals_dict, safe=safe_evaluation
                     ):
                         return
                 except Exception as error:
@@ -553,8 +575,8 @@ class MonitoringEngine:
                     # an empty expression reaches the SDK.
                     return
                 try:
-                    raw_value = ProbeEvaluator.safe_eval(
-                        metric_expression, globals_dict, locals_dict
+                    raw_value = ProbeEvaluator.evaluate(
+                        metric_expression, globals_dict, locals_dict, safe=safe_evaluation
                     )
                 except Exception as error:
                     self._report_metric_error(probe, str(error))
@@ -578,8 +600,8 @@ class MonitoringEngine:
             )
             if correlation_expression:
                 try:
-                    correlation_value = ProbeEvaluator.safe_eval(
-                        correlation_expression, globals_dict, locals_dict
+                    correlation_value = ProbeEvaluator.evaluate(
+                        correlation_expression, globals_dict, locals_dict, safe=safe_evaluation
                     )
                 except Exception as error:
                     self._report_metric_error(probe, f"Error: {error}")

{hyperprobe_agent-1.2.26b3 → hyperprobe_agent-1.2.27}/hyperprobe/core/safety.py

@@ -1,5 +1,6 @@
 import time
 import threading
+from collections import deque
 
 class AgentHealth:
     GREEN = 'GREEN'   # All good
@@ -8,6 +9,14 @@ class AgentHealth:
 
 
 class SafetyMonitor:
+    _SAMPLE_INTERVAL_SECONDS = 0.1
+    _LAG_WINDOW_SIZE = 10
+    _LAG_YELLOW_BREACHES = 4
+    _LAG_RED_BREACHES = 7
+    _SEVERE_LAG_WINDOW_SIZE = 5
+    _SEVERE_LAG_RED_BREACHES = 3
+    _SEVERE_LAG_MULTIPLIER = 4.0
+
     def __init__(self, on_state_change, max_lag_ms=50.0, pause_budget_ms=15.0):
         self.on_state_change = on_state_change
         self.max_lag_ms = max_lag_ms
@@ -17,6 +26,7 @@ class SafetyMonitor:
         self.cumulative_pause_time = 0.0
         self.last_window_reset = time.monotonic()
         self.last_thread_lag_ms = 0.0
+        self.thread_lag_samples = deque(maxlen=self._LAG_WINDOW_SIZE)
         
         self.lock = threading.RLock()
         self._notification_lock = threading.RLock()
@@ -42,47 +52,79 @@ class SafetyMonitor:
     def report_pause_duration(self, ms: float):
         with self.lock:
             self.cumulative_pause_time += ms
-            transition = self._evaluate_health_locked(self.last_thread_lag_ms)
+            transition = self._evaluate_health_locked()
 
         self._notify_state_change(transition)
 
     def _run_loop(self):
-        last_heartbeat = time.monotonic()
+        while self.is_running:
+            wait_started_at = time.monotonic()
+            if self.stop_event.wait(self._SAMPLE_INTERVAL_SECONDS):
+                break
 
-        while self.is_running and not self.stop_event.wait(0.1):
             now = time.monotonic()
-            thread_lag_ms = (now - last_heartbeat - 0.1) * 1000.0
-            last_heartbeat = now
+            thread_lag_ms = max(
+                0.0,
+                (
+                    now
+                    - wait_started_at
+                    - self._SAMPLE_INTERVAL_SECONDS
+                ) * 1000.0,
+            )
 
             with self.lock:
-                self.last_thread_lag_ms = thread_lag_ms
+                self._record_thread_lag_locked(thread_lag_ms)
                 if now - self.last_window_reset > 1.0:
                     self.cumulative_pause_time = 0.0
                     self.last_window_reset = now
 
-                transition = self._evaluate_health_locked(thread_lag_ms)
+                transition = self._evaluate_health_locked()
 
             self._notify_state_change(transition)
 
-    def _check_health(self, thread_lag_ms: float = 0.0):
+    def _check_health(self, thread_lag_ms=None):
         """
-        Preserves the existing method signature while ensuring that
-        callbacks execute outside the state lock.
+        Records an optional lag sample and executes callbacks outside the
+        state lock.
         """
         with self.lock:
-            transition = self._evaluate_health_locked(thread_lag_ms)
+            if thread_lag_ms is not None:
+                self._record_thread_lag_locked(thread_lag_ms)
+            transition = self._evaluate_health_locked()
 
         self._notify_state_change(transition)
 
-    def _evaluate_health_locked(self, thread_lag_ms: float = 0.0):
+    def _record_thread_lag_locked(self, thread_lag_ms: float):
+        thread_lag_ms = max(0.0, thread_lag_ms)
+        self.last_thread_lag_ms = thread_lag_ms
+        self.thread_lag_samples.append(thread_lag_ms)
+
+    def _evaluate_health_locked(self):
         previous_health = self.health
         reason = None
 
-        if thread_lag_ms > self.max_lag_ms:
+        recent_lags = list(self.thread_lag_samples)
+        lag_breaches = sum(
+            lag > self.max_lag_ms for lag in recent_lags
+        )
+        severe_lag_ms = self.max_lag_ms * self._SEVERE_LAG_MULTIPLIER
+        severe_lag_breaches = sum(
+            lag > severe_lag_ms
+            for lag in recent_lags[-self._SEVERE_LAG_WINDOW_SIZE:]
+        )
+
+        if severe_lag_breaches >= self._SEVERE_LAG_RED_BREACHES:
             self.health = AgentHealth.RED
             reason = (
-                f"Execution Thread Lag ({thread_lag_ms:.1f}ms) exceeded "
-                f"limit ({self.max_lag_ms}ms)"
+                f"Severe Execution Thread Lag exceeded {severe_lag_ms}ms in "
+                f"{severe_lag_breaches}/{self._SEVERE_LAG_WINDOW_SIZE} "
+                f"recent readings"
+            )
+        elif lag_breaches >= self._LAG_RED_BREACHES:
+            self.health = AgentHealth.RED
+            reason = (
+                f"Execution Thread Lag exceeded {self.max_lag_ms}ms in "
+                f"{lag_breaches}/{self._LAG_WINDOW_SIZE} recent readings"
             )
         elif self.cumulative_pause_time > self.pause_budget_ms:
             self.health = AgentHealth.RED
@@ -90,12 +132,19 @@ class SafetyMonitor:
                 f"Cumulative Pause Budget ({self.cumulative_pause_time:.1f}ms) "
                 f"exceeded limit ({self.pause_budget_ms}ms)"
             )
-        elif thread_lag_ms > self.max_lag_ms / 2.0:
+        elif severe_lag_breaches > 0:
+            self.health = AgentHealth.YELLOW
+            reason = (
+                f"Moderate impact: Severe Execution Thread Lag exceeded "
+                f"{severe_lag_ms}ms in {severe_lag_breaches}/"
+                f"{self._SEVERE_LAG_WINDOW_SIZE} recent readings"
+            )
+        elif lag_breaches >= self._LAG_YELLOW_BREACHES:
             self.health = AgentHealth.YELLOW
             reason = (
-                f"Moderate impact: Execution Thread Lag "
-                f"({thread_lag_ms:.1f}ms) reached 50% of limit "
-                f"({self.max_lag_ms}ms)"
+                f"Moderate impact: Execution Thread Lag exceeded "
+                f"{self.max_lag_ms}ms in {lag_breaches}/"
+                f"{self._LAG_WINDOW_SIZE} recent readings"
             )
         elif self.cumulative_pause_time > self.pause_budget_ms / 2.0:
             self.health = AgentHealth.YELLOW

{hyperprobe_agent-1.2.26b3 → hyperprobe_agent-1.2.27}/hyperprobe_agent.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperprobe-agent
-Version: 1.2.26b3
+Version: 1.2.27
 Summary: Production-grade, non-breaking live debugger and telemetry agent for Python.
 Home-page: https://www.hyperprobe.co
 Author: Arif, Saksham, Karan
@@ -98,7 +98,8 @@ Configure the agent using the following environment variables:
 | Variable | Description | Default |
 | --- | --- | --- |
 | `HYPERPROBE_BROKER_URL` | The URL of the HyperProbe Telemetry Broker. | *Required* |
-| `HYPERPROBE_SERVICE_ID` | A unique name identifying this service. | *Required* |
+| `HYPERPROBE_SERVICE_ID` | UUIDv4 service identifier provided by the HyperProbe dashboard. | *Required* |
+| `HYPERPROBE_ALLOW_NON_UUID` | Set to `yes` only to allow a legacy non-UUID service identifier. | *(unset)* |
 | `HYPERPROBE_ENVIRONMENT` | Deployment environment name (e.g., `production`, `staging`). | *Required* |
 | `HYPERPROBE_COMMIT_SHA` or `GIT_COMMIT` | Git commit SHA of the running application version. | *Required* |
 | `HYPERPROBE_DISABLED` | Set to `YES` to explicitly disable the agent. | *(unset)* |
@@ -109,7 +110,7 @@ Configure the agent using the following environment variables:
 | `HYPERPROBE_BANDWIDTH_KB_PER_SEC` | Max bandwidth limit for telemetry transmissions (quota). | `1024` (1 MB) |
 | `HYPERPROBE_RPC_TIMEOUT_SEC` | Deadline for broker RPCs. | `10` |
 | `HYPERPROBE_COOLDOWN_SEC` | Tracing suspension duration after a RED safety state. | `10` |
-| `HYPERPROBE_MAX_LAG_MS` | Execution-thread lag threshold for the safety monitor. | `50` |
+| `HYPERPROBE_MAX_LAG_MS` | Per-reading scheduler-lag threshold. YELLOW requires 4/10 breaches; RED requires 7/10 breaches or 3/5 readings above 4x the threshold. | `50` |
 | `HYPERPROBE_PAUSE_BUDGET_MS` | Per-second capture pause budget for the safety monitor. | `15` |
 | `HYPERPROBE_REDACT_KEYS` | Comma-separated key patterns to redact. | `password,secret,token,authorization,cookie,key,signature` |
 | `HYPERPROBE_REDACT_VALUES` | Comma-separated value patterns to redact. | *(empty)* |
@@ -118,8 +119,22 @@ Configure the agent using the following environment variables:
 | `HYPERPROBE_STACK_FRAME_DEPTH` | Maximum captured stack-frame depth. | `3` |
 | `HYPERPROBE_MAX_OBJECT_PROPERTIES` | Maximum serialized properties per object. | `50` |
 | `HYPERPROBE_MAX_STRING_LENGTH` | Maximum serialized string length. | `1024` |
+| `HYPERPROBE_DISABLE_SAFE_EVALUATION` | Set to `true` to explicitly disable safe evaluation restrictions and allow arbitrary method/function calls in probe expressions. | `false` |
 | `HYPERPROBE_FORK_MODE` | Set to `worker` for preloaded, prefork servers. The parent defers agent initialization and every worker starts fresh process-local state. | `none` |
 
+Programmatic integrations can set `allow_non_uuid=True` for the same legacy
+bypass. Without an explicit bypass, a non-UUIDv4 service ID prevents agent
+startup while the host application continues normally.
+
+### Safe Evaluation & Security Considerations
+
+By default, **safe evaluation is enabled** (`HYPERPROBE_DISABLE_SAFE_EVALUATION=false`). In safe mode:
+- Method and function calls are strictly restricted to a narrow allowlist of side-effect free standard operations.
+- State mutations, assignments, and arbitrary function invocations (such as database calls, network I/O, file operations, or state modifications) are prevented.
+
+**Disabling Safe Evaluation (`HYPERPROBE_DISABLE_SAFE_EVALUATION=true`):**
+> ⚠️ **Security Warning**: Setting `HYPERPROBE_DISABLE_SAFE_EVALUATION=true` allows conditions, watch expressions, and log templates to execute arbitrary functions and methods in the host application process. This may lead to unintended side effects, state mutations, performance degradation, or security risks if expressions invoke mutating or blocking operations. Only disable safe evaluation in trusted environments where dynamic method evaluation is strictly required.
+
 ### Debug logging
 
 Set `DEBUG` to a comma- or space-separated list of namespaces. Patterns accept

{hyperprobe_agent-1.2.26b3 → hyperprobe_agent-1.2.27}/hyperprobe_agent.egg-info/SOURCES.txt

@@ -29,5 +29,6 @@ tests/test_metric_probes.py
 tests/test_multithreading_integration.py
 tests/test_p1_regressions.py
 tests/test_probe_output.py
+tests/test_safety.py
 tests/test_serializer.py
 tests/test_startup.py

{hyperprobe_agent-1.2.26b3 → hyperprobe_agent-1.2.27}/setup.py

@@ -7,7 +7,7 @@ long_description = (this_directory / "README.md").read_text() if (this_directory
 
 setup(
     name="hyperprobe-agent",
-    version="1.2.26beta3",
+    version="1.2.27",
     author="Arif, Saksham, Karan",
     author_email="arif@hypertest.co, saksham@hypertest.co, karan@hypertest.co",
     description="Production-grade, non-breaking live debugger and telemetry agent for Python.",