hyperprobe-agent 1.2.24__py3-none-any.whl

hyperprobe/core/evaluator.py

@@ -0,0 +1,119 @@
+import re
+import ast
+from functools import lru_cache
+
+from hyperprobe.core.logger import get_logger
+
+logger = get_logger("hyperprobe:evaluator")
+
+SAFE_BUILTINS = {
+    "len": len, "str": str, "int": int, "float": float, 
+    "bool": bool, "list": list, "dict": dict, "set": set,
+    "max": max, "min": min, "abs": abs, "round": round,
+    "isinstance": isinstance, "type": type
+}
+
+COMPILED_CACHE_SIZE = 200
+
+SAFE_METHODS = {
+    # Dictionary/List read-only methods
+    "keys", "values", "items", "count",
+    # String read-only methods
+    "lower", "upper",
+    "isdigit", "isalpha", "isnumeric", "isalnum",
+}
+
+class SafeASTVisitor(ast.NodeVisitor):
+    def visit_Call(self, node):
+        # 1. Is it a direct function call? e.g. len(items)
+        if isinstance(node.func, ast.Name):
+            if node.func.id not in SAFE_BUILTINS:
+                raise ValueError(f"Function call '{node.func.id}' is not allowed.")
+                
+        # 2. Is it a method call on an object? e.g. user.get_id() or my_dict.keys()
+        elif isinstance(node.func, ast.Attribute):
+            method_name = node.func.attr
+            if method_name not in SAFE_METHODS:
+                raise ValueError(f"Method call '.{method_name}()' is strictly forbidden.")
+                
+        else:
+            raise ValueError("Complex dynamic calls are strictly forbidden.")
+            
+        self.generic_visit(node)
+
+
+class ProbeEvaluator:
+    _placeholder_regex = re.compile(r'\$?\{([^}]+)\}')
+
+    @classmethod
+    def _get_or_compile_safe(cls, expr: str):
+        # Normalize the string to prevent duplicate cache entries
+        clean_expr = expr.strip()
+
+        return cls._compile_safe(clean_expr)
+
+    @staticmethod
+    @lru_cache(maxsize=COMPILED_CACHE_SIZE)
+    def _compile_safe(clean_expr: str):
+        # Cache misses are parsed and compiled once; least-recently-used
+        # expressions are evicted after the bounded cache reaches capacity.
+        if len(clean_expr) > 256:
+            raise ValueError("Expression is too long (max 256 characters).")
+
+        tree = ast.parse(clean_expr, mode='eval')
+        visitor = SafeASTVisitor()
+        visitor.visit(tree)
+        
+        # Compile it to bytecode
+        compiled_code = compile(tree, filename="<string>", mode="eval")
+        
+        return compiled_code
+
+    @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
+
+        # Grab the pre-compiled bytecode instantly
+        compiled = cls._get_or_compile_safe(expr)
+        
+        # Execute the bytecode
+        return eval(compiled, safe_globals, locals_dict)
+
+    @classmethod
+    def evaluate_log_template(cls, template: str, globals_dict: dict, locals_dict: dict) -> str:
+        """Parses and safely formats a log template string."""
+        if not template:
+            return ""
+        
+        result = []
+        last_idx = 0
+        for match in cls._placeholder_regex.finditer(template):
+            # Append plain text preceding placeholder
+            result.append(template[last_idx:match.start()])
+            expr = match.group(1).strip()
+            
+            try:
+                # Safely execute expression
+                val = cls.safe_eval(expr, globals_dict, locals_dict)
+                result.append(str(val))
+            except Exception as e:
+                result.append(f"<Error: {type(e).__name__}: {str(e)}>")
+            last_idx = match.end()
+            
+        result.append(template[last_idx:])
+        return "".join(result)
+
+    @classmethod
+    def evaluate_watches(cls, watch_expressions: list, globals_dict: dict, locals_dict: dict) -> dict:
+        """Evaluates a set of independent watch expressions."""
+        results = {}
+        if not watch_expressions:
+            return results
+        for expr in watch_expressions:
+            try:
+                results[expr] = cls.safe_eval(expr, globals_dict, locals_dict)
+            except Exception as e:
+                results[expr] = f"Error: {type(e).__name__}: {str(e)}"
+        return results

hyperprobe/core/injection/sitecustomize.py

@@ -0,0 +1,18 @@
+import os
+import sys
+
+# This file acts as an automatic injection point for Python.
+# When a directory containing this file is injected into PYTHONPATH, 
+# Python will automatically execute it before the main application code starts.
+
+try:
+    from hyperprobe.agent import HyperProbeAgent
+
+    HyperProbeAgent.start({
+        "broker_url": os.getenv("HYPERPROBE_BROKER_URL"),
+        "service_id": os.getenv("HYPERPROBE_SERVICE_ID"),
+        "environment": os.getenv("HYPERPROBE_ENVIRONMENT"),
+        "commit_sha": os.getenv("HYPERPROBE_COMMIT_SHA") or os.getenv("GIT_COMMIT")
+    })
+except Exception as e:
+    print(f"\033[1m\033[33m⚠️ [HyperProbe] CRITICAL: Agent failed to initialize ({type(e).__name__}: {e}). Running application uninstrumented.", file=sys.stderr)

hyperprobe/core/logger.py

@@ -0,0 +1,121 @@
+"""Small, dependency-free namespace debugging for the HyperProbe SDK.
+
+The ``DEBUG`` environment variable accepts comma- or whitespace-separated
+namespace patterns. ``*`` matches any characters and a pattern prefixed with
+``-`` excludes a namespace.
+"""
+
+import os
+import re
+import sys
+import threading
+
+
+_SELECTOR_SEPARATOR = re.compile(r"[\s,]+")
+_COLOR_CODES = (31, 32, 33, 34, 35, 36, 91, 92, 93, 94, 95, 96)
+_DISABLED_COLOR_VALUES = {"0", "false", "no", "off"}
+_logger_cache: dict[str, "HyperProbeLogger"] = {}
+_logger_cache_lock = threading.Lock()
+
+
+def _compile_selector(pattern: str) -> re.Pattern[str]:
+    """Compile a Node-style namespace selector where only ``*`` is special."""
+    return re.compile("^" + re.escape(pattern).replace(r"\*", ".*?") + "$")
+
+
+def _parse_selectors(value: str | None) -> tuple[list[re.Pattern[str]], list[re.Pattern[str]]]:
+    enabled: list[re.Pattern[str]] = []
+    skipped: list[re.Pattern[str]] = []
+
+    for selector in _SELECTOR_SEPARATOR.split(value or ""):
+        if not selector:
+            continue
+
+        is_skip = selector.startswith("-")
+        pattern = selector[1:] if is_skip else selector
+        if not pattern:
+            continue
+
+        (skipped if is_skip else enabled).append(_compile_selector(pattern))
+
+    return enabled, skipped
+
+
+def _matches_selector(pattern: re.Pattern[str], namespace: str) -> bool:
+    return pattern.fullmatch(namespace) is not None
+
+
+def is_namespace_enabled(namespace: str, debug_value: str | None = None) -> bool:
+    """Return whether ``namespace`` is selected by ``debug_value`` or ``DEBUG``."""
+    enabled, skipped = _parse_selectors(
+        os.getenv("DEBUG") if debug_value is None else debug_value
+    )
+    return (
+        bool(enabled)
+        and not any(_matches_selector(pattern, namespace) for pattern in skipped)
+        and any(_matches_selector(pattern, namespace) for pattern in enabled)
+    )
+
+
+def _namespace_color(namespace: str) -> int:
+    # Avoid Python's randomized hash so a namespace keeps its color between runs.
+    value = sum((index + 1) * ord(character) for index, character in enumerate(namespace))
+    return _COLOR_CODES[value % len(_COLOR_CODES)]
+
+
+def _colors_enabled(stream: object) -> bool:
+    configured = os.getenv("DEBUG_COLORS")
+    if configured is not None:
+        return configured.strip().lower() not in _DISABLED_COLOR_VALUES
+    return bool(getattr(stream, "isatty", lambda: False)())
+
+
+class HyperProbeLogger:
+    """A namespace logger controlled by the ``DEBUG`` environment variable."""
+
+    def __init__(self, namespace: str = "hyperprobe:agent"):
+        self.namespace = namespace
+        self.enabled = is_namespace_enabled(namespace)
+        self.color = _namespace_color(namespace)
+
+    def _prefix(self, stream: object) -> str:
+        if _colors_enabled(stream):
+            return f"\033[{self.color}m{self.namespace}\033[0m"
+        return self.namespace
+
+    def _write(self, message: str, stream: object) -> None:
+        print(f"{self._prefix(stream)} {message}", file=stream, flush=True)
+
+    def info(self, message: str) -> None:
+        if self.enabled:
+            self._write(message, sys.stdout)
+
+    def error(self, message: str) -> None:
+        if self.enabled:
+            self._write(message, sys.stderr)
+
+    def forceInfo(self, message: str) -> None:
+        """Write an informational message without applying the ``DEBUG`` gate."""
+        print(message, file=sys.stdout, flush=True)
+
+    def forceError(self, message: str) -> None:
+        """Write an error message without applying the ``DEBUG`` gate."""
+        print(message, file=sys.stderr, flush=True)
+
+
+def get_logger(namespace: str) -> HyperProbeLogger:
+    """Return the process-wide logger for a namespace.
+
+    ``DEBUG`` is intentionally read when a namespace is first created, matching
+    the launch-time configuration behavior of the previous logger.
+    """
+    with _logger_cache_lock:
+        logger = _logger_cache.get(namespace)
+        if logger is None:
+            logger = HyperProbeLogger(namespace)
+            _logger_cache[namespace] = logger
+        return logger
+
+
+# Existing imports continue to work and now use the primary agent namespace.
+logger = get_logger("hyperprobe:agent")