mca-sdk 0.1.dev20__py3-none-any.whl → 0.1.dev37__py3-none-any.whl

mca_sdk/__init__.py

@@ -22,15 +22,7 @@ Example:
     >>> client.shutdown()
 """
 
-try:
-    from ._version import version as __version__
-except ImportError:
-    try:
-        from importlib.metadata import version, PackageNotFoundError
-
-        __version__ = version("mca-sdk")
-    except (ImportError, PackageNotFoundError):
-        __version__ = "unknown"
+from .version import __version__
 
 from .core import MCAClient
 from .config import MCAConfig

mca_sdk/_version.py

@@ -1,5 +1,6 @@
-# file generated by setuptools-scm
+# file generated by vcs-versioning
 # don't change, don't track in version control
+from __future__ import annotations
 
 __all__ = [
     "__version__",
@@ -10,25 +11,14 @@ __all__ = [
     "commit_id",
 ]
 
-TYPE_CHECKING = False
-if TYPE_CHECKING:
-    from typing import Tuple
-    from typing import Union
-
-    VERSION_TUPLE = Tuple[Union[int, str], ...]
-    COMMIT_ID = Union[str, None]
-else:
-    VERSION_TUPLE = object
-    COMMIT_ID = object
-
 version: str
 __version__: str
-__version_tuple__: VERSION_TUPLE
-version_tuple: VERSION_TUPLE
-commit_id: COMMIT_ID
-__commit_id__: COMMIT_ID
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
 
-__version__ = version = '0.1.dev20'
-__version_tuple__ = version_tuple = (0, 1, 'dev20')
+__version__ = version = '0.1.dev37'
+__version_tuple__ = version_tuple = (0, 1, 'dev37')
 
 __commit_id__ = commit_id = None

mca_sdk/autolog/_base.py

@@ -171,36 +171,45 @@ class BasePatcher:
         }
         attrs.update(additional_attrs)
 
-        # Add input data if requested (with size limit)
-        if self.capture_input and args:
-            input_data = self._capture_data_safely(args[0], "input")
-            if input_data is not None:
-                attrs.update(input_data)
-
         # Track timing manually for accurate latency metric
         start_time = time.perf_counter()
 
+        # Story 8.5: Delegate to record_prediction() for unified schema
+        # Extract raw input/output data and let record_prediction() handle serialization
+        # Issue #8 Fix: Use same logic as decorator - single arg direct, else wrap
+        input_for_capture = None
+        if self.capture_input and (args or kwargs):
+            if len(args) == 1 and not kwargs:
+                # Single positional arg - pass directly
+                input_for_capture = args[0]
+            else:
+                # Multi-args, kwargs-only, or mixed - wrap everything to preserve all data
+                input_for_capture = {"args": args, "kwargs": kwargs}
+
+        output_for_capture = None  # Set after method call
+
         # Execute with instrumentation
         try:
-            with client.trace(span_name, **attrs) as span:
+            with client.trace(span_name, **attrs):
                 # Call the wrapped method (already bound to instance by wrapt)
                 result = original_method(*args, **kwargs)
 
                 # Calculate actual latency
                 latency_seconds = time.perf_counter() - start_time
 
-                # Add output data if requested (with size limit)
+                # Capture output if requested
                 if self.capture_output:
-                    output_data = self._capture_data_safely(result, "output")
-                    if output_data is not None:
-                        attrs.update(output_data)
-                        # Add output attributes to span as well
-                        for key, value in output_data.items():
-                            span.set_attribute(key, value)
-
-                # Record prediction metric with actual latency
+                    output_for_capture = result
+
+                # Story 8.5: Delegate to record_prediction() with raw data
+                # This ensures consistent schema (data, shape, truncated) across all instrumentation methods
                 try:
-                    client.record_prediction(latency=latency_seconds, **attrs)
+                    client.record_prediction(
+                        input_data=input_for_capture,
+                        output=output_for_capture,
+                        latency=latency_seconds,
+                        **attrs,
+                    )
                 except Exception as metric_error:
                     logger.warning(f"Failed to record prediction metric: {metric_error}")
 
@@ -235,10 +244,15 @@ class BasePatcher:
                 # Log but don't crash if error recording fails
                 logger.warning(f"Failed to record exception in span: {span_error}")
 
+            # Story 8.5: Delegate to record_prediction() even for failed predictions
             # Record failed prediction metric with actual latency
-            # This happens OUTSIDE the span try/except so it always executes
             try:
-                client.record_prediction(latency=latency_seconds, **attrs)
+                client.record_prediction(
+                    input_data=input_for_capture,
+                    output=None,  # No output on error
+                    latency=latency_seconds,
+                    **attrs,
+                )
             except Exception as metric_error:
                 logger.warning(f"Failed to record failed prediction metric: {metric_error}")
 

mca_sdk/buffering/queue.py

@@ -290,7 +290,7 @@ class TelemetryQueue:
                 f"Original: {path}, Expanded: {expanded}, Error: {type(e).__name__}"
             )
             raise BufferingError(
-                f"Invalid persist_path: {path}. " f"Could not resolve to canonical path: {e}"
+                f"Invalid persist_path: {path}. Could not resolve to canonical path: {e}"
             )
 
         # Step 3: Check for path traversal in CANONICAL path (Finding #6)
@@ -333,7 +333,7 @@ class TelemetryQueue:
         for prefix in sensitive_prefixes:
             if canonical == prefix or canonical.startswith(prefix + "/"):
                 logger.warning(
-                    f"SECURITY: Attempted write to sensitive directory. " f"Path: {canonical}"
+                    f"SECURITY: Attempted write to sensitive directory. Path: {canonical}"
                 )
                 raise BufferingError(
                     f"Cannot persist queue to sensitive system directory: {canonical}. "
@@ -355,25 +355,25 @@ class TelemetryQueue:
         # Add custom directories if provided, filtering empty strings (Finding #2)
         if config and hasattr(config, "persist_allowed_dirs") and config.persist_allowed_dirs:
             custom_dirs = [d.strip() for d in config.persist_allowed_dirs.split(",") if d.strip()]
-            # Canonicalize custom dirs to handle ~ and relative paths (Finding #9)
-            canonical_custom = [
-                os.path.realpath(os.path.expanduser(d), strict=False) for d in custom_dirs
-            ]
-            static_allowed.extend(canonical_custom)
-            logger.debug(f"Using custom allowed directories: {canonical_custom}")
-
-        # Step 6: Whitelist validation with proper directory boundary (Finding #1)
+            static_allowed.extend(custom_dirs)
+            logger.debug(f"Using custom allowed directories: {custom_dirs}")
+
+        # Canonicalize all whitelist entries for consistent cross-platform comparison
+        canonical_allowed = [
+            os.path.realpath(os.path.expanduser(p), strict=False) for p in static_allowed
+        ]
+
+        # Step 6: Whitelist validation using commonpath for proper directory boundary check
         def _is_whitelisted(canonical_path: str, allowed: list) -> bool:
             for prefix in allowed:
-                if (
-                    canonical_path == prefix
-                    or canonical_path.startswith(prefix + "/")
-                    or canonical_path.startswith(prefix + os.sep)
-                ):
-                    return True
+                try:
+                    if os.path.commonpath([canonical_path, prefix]) == prefix:
+                        return True
+                except ValueError:
+                    continue
             return False
 
-        if not _is_whitelisted(canonical, static_allowed):
+        if not _is_whitelisted(canonical, canonical_allowed):
             # Find closest valid directory for helpful error message (Finding #4)
             def path_similarity(dir1: str, dir2: str) -> int:
                 """Count matching path components"""
@@ -382,13 +382,13 @@ class TelemetryQueue:
                 return sum(1 for a, b in zip(parts1, parts2) if a == b)
 
             sorted_allowed = sorted(
-                static_allowed,
+                canonical_allowed,
                 key=lambda d: path_similarity(canonical, d),
                 reverse=True,
             )
             suggestion = sorted_allowed[0] if sorted_allowed else "~/.mca_sdk/"
 
-            logger.warning(f"SECURITY: Unauthorized persist_path. " f"Attempted: {canonical}")
+            logger.warning(f"SECURITY: Unauthorized persist_path. Attempted: {canonical}")
             raise BufferingError(
                 f"Unauthorized persist_path: {path}. "
                 f"Resolved to: {canonical}. "
@@ -437,7 +437,11 @@ class TelemetryQueue:
                 tmp_base = tempfile.gettempdir().rstrip("/")  # nosec B108
                 is_tmp_itself = parent_dir.rstrip("/") == tmp_base
 
-                if (dir_perms & stat.S_IWOTH) and not (has_sticky_bit and is_tmp_itself):
+                if (
+                    os.name != "nt"  # Windows NTFS always reports 0o777; skip Unix permission check
+                    and (dir_perms & stat.S_IWOTH)
+                    and not (has_sticky_bit and is_tmp_itself)
+                ):
                     logger.error(
                         f"SECURITY: Directory is world-writable (777/other+w). "
                         f"Path: {parent_dir}, Permissions: {oct(dir_perms)}"
@@ -498,7 +502,7 @@ class TelemetryQueue:
             # Log queue full event
             if was_full:
                 logger.warning(
-                    f"Telemetry queue full (size={self._max_size}), " "oldest item will be evicted"
+                    f"Telemetry queue full (size={self._max_size}), oldest item will be evicted"
                 )
 
             # deque with maxlen automatically evicts oldest when full
@@ -1171,8 +1175,8 @@ class TelemetryQueue:
 
             if file_size > max_file_size:
                 logger.error(
-                    f"Queue file too large: {file_size / (1024*1024):.1f}MB "
-                    f"(max: {max_file_size / (1024*1024):.1f}MB). "
+                    f"Queue file too large: {file_size / (1024 * 1024):.1f}MB "
+                    f"(max: {max_file_size / (1024 * 1024):.1f}MB). "
                     f"File may be corrupted or contains excessive data. "
                     f"Renaming to .corrupted to prevent OOM."
                 )

mca_sdk/cli/_bootstrap.py

@@ -108,10 +108,17 @@ def _auto_init():
     optional = {
         "collector_endpoint": os.environ.get("MCA_COLLECTOR_ENDPOINT"),
         "registry_url": os.environ.get("MCA_REGISTRY_URL"),
+        "use_gcp_auth": os.environ.get("MCA_USE_GCP_AUTH", "false").lower() == "true",
+        "allow_insecure_collector": os.environ.get("MCA_ALLOW_INSECURE_COLLECTOR", "false").lower()
+        == "true",
         "model_version": os.environ.get("MCA_MODEL_VERSION"),
         "model_type": os.environ.get("MCA_MODEL_TYPE"),
         "model_category": os.environ.get("MCA_MODEL_CATEGORY"),
         "environment": os.environ.get("MCA_ENV"),
+        "gcp_logging_enabled": os.environ.get("MCA_GCP_LOGGING_ENABLED", "false").lower() == "true",
+        "gcp_project_id": os.environ.get("MCA_GCP_PROJECT_ID"),
+        "gcp_log_name": os.environ.get("MCA_GCP_LOG_NAME"),
+        "gcp_trace_enabled": os.environ.get("MCA_GCP_TRACE_ENABLED", "false").lower() == "true",
     }
 
     # Filter out None values
@@ -127,6 +134,24 @@ def _auto_init():
 
         mca_sdk._auto_client = client
 
+        # Story 8.5: Silently invoke autolog() to enable auto-instrumentation
+        # This enables structured telemetry capture for sklearn, xgboost, etc.
+        # Issue #6 Fix: Add kill switch to disable autolog in production if needed
+        if os.environ.get("MCA_DISABLE_AUTOLOG", "").lower() not in ("1", "true", "yes"):
+            try:
+                from mca_sdk import autolog
+
+                autolog()  # Patches ML frameworks with unified instrumentation
+                logger.info("MCA SDK autolog enabled")
+            except ImportError as e:
+                # ML framework dependencies missing - graceful degradation
+                logger.debug("autolog not enabled (missing dependencies): %s", e)
+            except Exception as e:
+                # Don't crash mca-instrument if autolog fails
+                logger.warning("autolog initialization failed: %s", e)
+        else:
+            logger.info("MCA SDK autolog disabled via MCA_DISABLE_AUTOLOG")
+
         # Register shutdown hook with timeout protection
         atexit.register(_shutdown_with_timeout, client, SHUTDOWN_TIMEOUT)