flock-core 0.4.542__py3-none-any.whl → 0.5.0__py3-none-any.whl

flock/{core/logging → logging}/logging.py

@@ -14,13 +14,12 @@ import logging
 import sys
 from typing import Literal
 
-from opentelemetry import trace
-
 # Always import Temporal workflow (since it's part of the project)
-from temporalio import workflow
+# from temporalio import workflow
+# with workflow.unsafe.imports_passed_through():
+from loguru import logger as loguru_logger
+from opentelemetry import trace
 
-with workflow.unsafe.imports_passed_through():
-    from loguru import logger as loguru_logger
 
 # ENABLED_FLOCK_LOGGER_LEVELS constant removed
 
@@ -42,13 +41,14 @@ def in_workflow_context() -> bool:
     It does this by attempting to call workflow.info() and returning True
     if successful. Otherwise, it returns False.
     """
-    try:
-        workflow.logger.debug("Checking if in workflow context...")
-        # loguru_logger.debug("Checking if in workflow context...")
-        # This call will succeed only if we're in a workflow context.
-        return bool(hasattr(workflow.info(), "is_replaying"))
-    except Exception:
-        return False
+    return False
+    # try:
+    #     workflow.logger.debug("Checking if in workflow context...")
+    #     # loguru_logger.debug("Checking if in workflow context...")
+    #     # This call will succeed only if we're in a workflow context.
+    #     return bool(hasattr(workflow.info(), "is_replaying"))
+    # except Exception:
+    #     return False
 
 
 def get_current_trace_id() -> str:
@@ -108,7 +108,7 @@ COLOR_MAP = {
 
 LOGGERS = [
     "flock",  # Core Flock orchestration
-    "flock.api", # Flock API specific logs
+    "flock.api",  # Flock API specific logs
     "agent",  # General agent operations
     "context",  # Context management
     "registry",  # Unified registry operations (new)
@@ -154,6 +154,7 @@ def color_for_category(category: str) -> str:
     if category in COLOR_MAP:
         return COLOR_MAP[category]
     parts = category.split(".")
+    # Try progressively shorter parent categories
     for i in range(len(parts) - 1, 0, -1):
         parent_category = ".".join(parts[:i])
         if parent_category in COLOR_MAP:
@@ -176,9 +177,7 @@ def custom_format(record):
     # MAX_LENGTH = 500 # Example value
     if len(message) > MAX_LENGTH:
         truncated_chars = len(message) - MAX_LENGTH
-        message = (
-            message[:MAX_LENGTH] + f"<yellow>...+({truncated_chars} chars)</yellow>"
-        )
+        message = message[:MAX_LENGTH] + f"<yellow>...+({truncated_chars} chars)</yellow>"
 
     # Determine if category needs bolding (can refine this logic)
     needs_bold = category in BOLD_CATEGORIES
@@ -246,7 +245,6 @@ class PrintAndFlushSink:
 
         Already flushed on every write call.
         """
-        pass
 
 
 # Configure Loguru for non-workflow (local/worker) contexts.
@@ -263,7 +261,9 @@ logging.basicConfig(level=LOG_LEVELS["ERROR"])  # Default to ERROR level for fal
 # loguru_logger.add("logs/flock.log", rotation="100 MB", retention="30 days", level="DEBUG")
 
 
-def get_default_severity(level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NO_LOGS", "SUCCESS"] | int) -> int:
+def get_default_severity(
+    level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NO_LOGS", "SUCCESS"] | int,
+) -> int:
     """Get the default severity for a given level."""
     if isinstance(level, str):
         level_str = level.upper()
@@ -271,9 +271,17 @@ def get_default_severity(level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CR
     return level
 
 
-def configure_logging(flock_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NO_LOGS", "SUCCESS"] | int,
-                      external_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NO_LOGS", "SUCCESS"] | int,
-                      specific_levels: dict[str, Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NO_LOGS", "SUCCESS"] | int] | None = None) -> None:
+def configure_logging(
+    flock_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NO_LOGS", "SUCCESS"]
+    | int,
+    external_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NO_LOGS", "SUCCESS"]
+    | int,
+    specific_levels: dict[
+        str,
+        Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "NO_LOGS", "SUCCESS"] | int,
+    ]
+    | None = None,
+) -> None:
     """Configure both external and internal Flock logging systems.
 
     Args:
@@ -282,19 +290,21 @@ def configure_logging(flock_level: Literal["DEBUG", "INFO", "WARNING", "ERROR",
         specific_levels (dict[str, str | int] | None, optional): A dictionary mapping
             logger names to their specific logging levels. Defaults to None.
     """
-    # Get default severity
+    global _DEFAULT_FLOCK_SEVERITY, _SPECIFIC_SEVERITIES
 
+    # Get default severity
     external_severity = get_default_severity(external_level)
     logging.basicConfig(level=external_severity)
 
-
     flock_severity = get_default_severity(flock_level)
+    _DEFAULT_FLOCK_SEVERITY = flock_severity  # Store for future loggers
 
     specific_severities = {}
     if specific_levels:
         for name, logger_level in specific_levels.items():
             severity = get_default_severity(logger_level)
             specific_severities[name] = severity
+            _SPECIFIC_SEVERITIES[name] = severity  # Store for future loggers
 
     # Apply to all cached loggers
     for logger_name, log_instance in _LOGGER_CACHE.items():
@@ -305,28 +315,26 @@ def configure_logging(flock_level: Literal["DEBUG", "INFO", "WARNING", "ERROR",
         log_instance.min_level_severity = target_severity
 
 
-
-
 # Define a dummy logger that does nothing
 class DummyLogger:
     """A dummy logger that does nothing when called."""
 
-    def debug(self, *args, **kwargs):  # noqa: D102
+    def debug(self, *args, **kwargs):
         pass
 
-    def info(self, *args, **kwargs):  # noqa: D102
+    def info(self, *args, **kwargs):
         pass
 
-    def warning(self, *args, **kwargs):  # noqa: D102
+    def warning(self, *args, **kwargs):
         pass
 
-    def error(self, *args, **kwargs):  # noqa: D102
+    def error(self, *args, **kwargs):
         pass
 
-    def exception(self, *args, **kwargs):  # noqa: D102
+    def exception(self, *args, **kwargs):
         pass
 
-    def success(self, *args, **kwargs):  # noqa: D102
+    def success(self, *args, **kwargs):
         pass
 
 
@@ -356,9 +364,9 @@ class FlockLogger:
         self.min_level_severity = initial_min_level_severity
 
     def _get_logger(self):
-        if in_workflow_context():
-            # Use Temporal's workflow.logger inside a workflow context.
-            return workflow.logger
+        # if in_workflow_context():
+        #     # Use Temporal's workflow.logger inside a workflow context.
+        #     return workflow.logger
         # Bind our logger with category and trace_id
         return loguru_logger.bind(
             name=self.name,
@@ -370,9 +378,7 @@ class FlockLogger:
         """Truncate a message if it exceeds max_length and add truncation indicator."""
         if len(message) > max_length:
             truncated_chars = len(message) - max_length
-            return (
-                message[:max_length] + f"...<yellow>+({truncated_chars} chars)</yellow>"
-            )
+            return message[:max_length] + f"...<yellow>+({truncated_chars} chars)</yellow>"
         return message
 
     def debug(
@@ -384,8 +390,10 @@ class FlockLogger:
         **kwargs,
     ) -> None:
         current_method_severity = LOG_LEVELS["DEBUG"]
-        if self.min_level_severity == LOG_LEVELS["NO_LOGS"] or \
-           current_method_severity < self.min_level_severity:
+        if (
+            self.min_level_severity == LOG_LEVELS["NO_LOGS"]
+            or current_method_severity < self.min_level_severity
+        ):
             return
         """Debug a message.
 
@@ -406,8 +414,10 @@ class FlockLogger:
         **kwargs,
     ) -> None:
         current_method_severity = LOG_LEVELS["INFO"]
-        if self.min_level_severity == LOG_LEVELS["NO_LOGS"] or \
-           current_method_severity < self.min_level_severity:
+        if (
+            self.min_level_severity == LOG_LEVELS["NO_LOGS"]
+            or current_method_severity < self.min_level_severity
+        ):
             return
         """Info a message.
 
@@ -428,8 +438,10 @@ class FlockLogger:
         **kwargs,
     ) -> None:
         current_method_severity = LOG_LEVELS["WARNING"]
-        if self.min_level_severity == LOG_LEVELS["NO_LOGS"] or \
-           current_method_severity < self.min_level_severity:
+        if (
+            self.min_level_severity == LOG_LEVELS["NO_LOGS"]
+            or current_method_severity < self.min_level_severity
+        ):
             return
         """Warning a message.
 
@@ -450,8 +462,10 @@ class FlockLogger:
         **kwargs,
     ) -> None:
         current_method_severity = LOG_LEVELS["ERROR"]
-        if self.min_level_severity == LOG_LEVELS["NO_LOGS"] or \
-           current_method_severity < self.min_level_severity:
+        if (
+            self.min_level_severity == LOG_LEVELS["NO_LOGS"]
+            or current_method_severity < self.min_level_severity
+        ):
             return
         """Error a message.
 
@@ -471,9 +485,11 @@ class FlockLogger:
         max_length: int = MAX_LENGTH,
         **kwargs,
     ) -> None:
-        current_method_severity = LOG_LEVELS["ERROR"] # Exception implies ERROR level
-        if self.min_level_severity == LOG_LEVELS["NO_LOGS"] or \
-           current_method_severity < self.min_level_severity:
+        current_method_severity = LOG_LEVELS["ERROR"]  # Exception implies ERROR level
+        if (
+            self.min_level_severity == LOG_LEVELS["NO_LOGS"]
+            or current_method_severity < self.min_level_severity
+        ):
             return
         """Exception a message.
 
@@ -494,8 +510,10 @@ class FlockLogger:
         **kwargs,
     ) -> None:
         current_method_severity = LOG_LEVELS["SUCCESS"]
-        if self.min_level_severity == LOG_LEVELS["NO_LOGS"] or \
-           current_method_severity < self.min_level_severity:
+        if (
+            self.min_level_severity == LOG_LEVELS["NO_LOGS"]
+            or current_method_severity < self.min_level_severity
+        ):
             return
         """Success a message.
 
@@ -509,21 +527,22 @@ class FlockLogger:
 
 
 _LOGGER_CACHE: dict[str, FlockLogger] = {}
+_DEFAULT_FLOCK_SEVERITY: int = LOG_LEVELS["ERROR"]
+_SPECIFIC_SEVERITIES: dict[str, int] = {}
 
 
 def get_logger(name: str = "flock") -> FlockLogger:
     """Return a cached FlockLogger instance for the given name.
 
-    If the logger doesn't exist, it is created with 'enable_logging' set to False
-    by default (i.e., errors-only mode). Its state can then be changed by calling
-    the `configure_logging()` function.
+    If the logger doesn't exist, it is created using the configured severity level
+    from configure_logging() (default: ERROR). Respects specific_levels if configured.
     If a logger with the given name already exists in the cache, its 'min_level_severity'
     state is NOT modified by this function; it's simply returned.
     """
     if name not in _LOGGER_CACHE:
-        # New loggers default to errors-only (min_level_severity = ERROR_SEVERITY)
-        # until explicitly configured by configure_logging()
-        _LOGGER_CACHE[name] = FlockLogger(name, LOG_LEVELS["ERROR"])
+        # Check if there's a specific severity configured for this logger
+        severity = _SPECIFIC_SEVERITIES.get(name, _DEFAULT_FLOCK_SEVERITY)
+        _LOGGER_CACHE[name] = FlockLogger(name, severity)
     # The min_level_severity state of existing or newly created loggers
     # should be managed by the configure_logging() function.
     return _LOGGER_CACHE[name]
@@ -543,15 +562,13 @@ def truncate_for_logging(obj, max_item_length=100, max_items=10):
     """Truncate large data structures for logging purposes."""
     if isinstance(obj, str) and len(obj) > max_item_length:
         return obj[:max_item_length] + f"... ({len(obj) - max_item_length} more chars)"
-    elif isinstance(obj, dict):
+    if isinstance(obj, dict):
         if len(obj) > max_items:
             return {
-                k: truncate_for_logging(v)
-                for i, (k, v) in enumerate(obj.items())
-                if i < max_items
+                k: truncate_for_logging(v) for i, (k, v) in enumerate(obj.items()) if i < max_items
             }
         return {k: truncate_for_logging(v) for k, v in obj.items()}
-    elif isinstance(obj, list):
+    if isinstance(obj, list):
         if len(obj) > max_items:
             return [truncate_for_logging(item) for item in obj[:max_items]] + [
                 f"... ({len(obj) - max_items} more items)"

flock/{core/logging → logging}/telemetry.py

@@ -1,24 +1,28 @@
 """This module sets up OpenTelemetry tracing for a service."""
 
+import os
 import sys
 
 from opentelemetry import trace
 from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import SimpleSpanProcessor
-from temporalio import workflow
 
-from flock.core.logging.span_middleware.baggage_span_processor import (
+# from temporalio import workflow
+from flock.logging.span_middleware.baggage_span_processor import (
     BaggageAttributeSpanProcessor,
 )
+from flock.logging.telemetry_exporter.duckdb_exporter import (
+    DuckDBSpanExporter,
+)
 
-with workflow.unsafe.imports_passed_through():
-    from flock.core.logging.telemetry_exporter.file_exporter import (
-        FileSpanExporter,
-    )
-    from flock.core.logging.telemetry_exporter.sqlite_exporter import (
-        SqliteTelemetryExporter,
-    )
+# with workflow.unsafe.imports_passed_through():
+from flock.logging.telemetry_exporter.file_exporter import (
+    FileSpanExporter,
+)
+from flock.logging.telemetry_exporter.sqlite_exporter import (
+    SqliteTelemetryExporter,
+)
 
 
 class TelemetryConfig:
@@ -39,9 +43,12 @@ class TelemetryConfig:
         local_logging_dir: str | None = None,
         file_export_name: str | None = None,
         sqlite_db_name: str | None = None,
+        duckdb_name: str | None = None,
+        duckdb_ttl_days: int | None = None,
         enable_jaeger: bool = True,
         enable_file: bool = True,
         enable_sql: bool = True,
+        enable_duckdb: bool = True,
         enable_otlp: bool = True,
         otlp_protocol: str = "grpc",
         otlp_endpoint: str = "http://localhost:4317",
@@ -52,6 +59,7 @@ class TelemetryConfig:
         :param jaeger_endpoint: The Jaeger collector gRPC endpoint (e.g., "localhost:14250").
         :param file_export_path: If provided, spans will be written to this file.
         :param sqlite_db_path: If provided, spans will be stored in this SQLite DB.
+        :param duckdb_ttl_days: Delete traces older than this many days (default: None = keep forever).
         :param batch_processor_options: Dict of options for BatchSpanProcessor (e.g., {"max_export_batch_size": 10}).
         """
         self.service_name = service_name
@@ -59,18 +67,50 @@ class TelemetryConfig:
         self.jaeger_transport = jaeger_transport
         self.file_export_name = file_export_name
         self.sqlite_db_name = sqlite_db_name
+        self.duckdb_name = duckdb_name
+        self.duckdb_ttl_days = duckdb_ttl_days
         self.local_logging_dir = local_logging_dir
         self.batch_processor_options = batch_processor_options or {}
         self.enable_jaeger = enable_jaeger
         self.enable_file = enable_file
         self.enable_sql = enable_sql
+        self.enable_duckdb = enable_duckdb
         self.enable_otlp = enable_otlp
         self.otlp_protocol = otlp_protocol
         self.otlp_endpoint = otlp_endpoint
         self.global_tracer = None
+        self._configured: bool = False
+
+    def _should_setup(self) -> bool:
+        # Respect explicit disable flag for tests and minimal setups
+        if os.environ.get("FLOCK_DISABLE_TELEMETRY_AUTOSETUP", "").lower() in {
+            "1",
+            "true",
+            "yes",
+            "on",
+        }:
+            return False
+        try:
+            # If a provider is already installed (typically by user/tests), don't override it
+            from opentelemetry.sdk.trace import (
+                TracerProvider as SDKTracerProvider,  # type: ignore
+            )
+
+            current = trace.get_tracer_provider()
+            if isinstance(current, SDKTracerProvider):
+                return False
+        except Exception:
+            # If SDK isn't available or introspection fails, fall back to enabling
+            pass
+        return True
 
     def setup_tracing(self):
         """Set up OpenTelemetry tracing with the specified exporters."""
+        if self._configured:
+            return
+        if not self._should_setup():
+            return
+
         # Create a Resource with the service name.
         resource = Resource(attributes={"service.name": self.service_name})
         provider = TracerProvider(resource=resource)
@@ -97,13 +137,10 @@ class TelemetryConfig:
                     collector_endpoint=self.jaeger_endpoint,
                 )
             else:
-                raise ValueError(
-                    "Invalid JAEGER_TRANSPORT specified. Use 'grpc' or 'http'."
-                )
+                raise ValueError("Invalid JAEGER_TRANSPORT specified. Use 'grpc' or 'http'.")
 
             span_processors.append(SimpleSpanProcessor(jaeger_exporter))
 
-
         if self.enable_otlp:
             if self.otlp_protocol == "grpc":
                 from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
@@ -131,18 +168,21 @@ class TelemetryConfig:
 
         # If a file path is provided, add the custom file exporter.
         if self.file_export_name and self.enable_file:
-            file_exporter = FileSpanExporter(
-                self.local_logging_dir, self.file_export_name
-            )
+            file_exporter = FileSpanExporter(self.local_logging_dir, self.file_export_name)
             span_processors.append(SimpleSpanProcessor(file_exporter))
 
         # If a SQLite database path is provided, ensure the DB exists and add the SQLite exporter.
         if self.sqlite_db_name and self.enable_sql:
-            sqlite_exporter = SqliteTelemetryExporter(
-                self.local_logging_dir, self.sqlite_db_name
-            )
+            sqlite_exporter = SqliteTelemetryExporter(self.local_logging_dir, self.sqlite_db_name)
             span_processors.append(SimpleSpanProcessor(sqlite_exporter))
 
+        # If a DuckDB database path is provided, add the DuckDB exporter.
+        if self.duckdb_name and self.enable_duckdb:
+            duckdb_exporter = DuckDBSpanExporter(
+                self.local_logging_dir, self.duckdb_name, ttl_days=self.duckdb_ttl_days
+            )
+            span_processors.append(SimpleSpanProcessor(duckdb_exporter))
+
         # Register all span processors with the provider.
         for processor in span_processors:
             provider.add_span_processor(processor)
@@ -150,8 +190,9 @@ class TelemetryConfig:
         provider.add_span_processor(
             BaggageAttributeSpanProcessor(baggage_keys=["session_id", "run_id"])
         )
-        # self.global_tracer = trace.get_tracer("flock")
+        self.global_tracer = trace.get_tracer("flock")
         sys.excepthook = self.log_exception_to_otel
+        self._configured = True
 
     def log_exception_to_otel(self, exc_type, exc_value, exc_traceback):
         """Log unhandled exceptions to OpenTelemetry."""
@@ -160,11 +201,10 @@ class TelemetryConfig:
             sys.__excepthook__(exc_type, exc_value, exc_traceback)
             return
 
+        if not self.global_tracer:
+            return
+
         # Use OpenTelemetry to record the exception
-        with self.global_tracer.start_as_current_span(
-            "UnhandledException"
-        ) as span:
+        with self.global_tracer.start_as_current_span("UnhandledException") as span:
             span.record_exception(exc_value)
-            span.set_status(
-                trace.Status(trace.StatusCode.ERROR, str(exc_value))
-            )
+            span.set_status(trace.Status(trace.StatusCode.ERROR, str(exc_value)))

flock/{core/logging → logging}/telemetry_exporter/base_exporter.py

@@ -25,14 +25,14 @@ class TelemetryExporter(SpanExporter, ABC):
             self.shutdown()
 
     @abstractmethod
-    def export(self, spans) -> SpanExportResult | None:
+    def export(self, spans) -> SpanExportResult:  # type: ignore[override]
         """Export spans to the configured backend.
 
         To be implemented by subclasses.
+        May return SUCCESS, FAILURE, or None (handled by _export wrapper).
         """
         raise NotImplementedError("Subclasses must implement the export method")
 
     @abstractmethod
     def shutdown(self):
         """Cleanup resources, if any. Optional for subclasses."""
-        pass