flock-core 0.2.4__py3-none-any.whl → 0.2.5__py3-none-any.whl

flock/__init__.py

@@ -1,5 +1,8 @@
 """Flock package initialization."""
 
+from opentelemetry import trace
+
 from flock.config import TELEMETRY
 
 tracer = TELEMETRY.setup_tracing()
+tracer = trace.get_tracer(__name__)

flock/config.py

@@ -1,29 +1,47 @@
 # flock/config.py
-import os
+from decouple import config
 
 from flock.core.logging.telemetry import TelemetryConfig
 
 # -- Connection and External Service Configurations --
-TEMPORAL_SERVER_URL = os.getenv("TEMPORAL_SERVER_URL", "localhost:7233")
-DEFAULT_MODEL = os.getenv("DEFAULT_MODEL", "openai/gpt-4o")
+TEMPORAL_SERVER_URL = config("TEMPORAL_SERVER_URL", "localhost:7233")
+DEFAULT_MODEL = config("DEFAULT_MODEL", "openai/gpt-4o")
+
 
 # API Keys and related settings
-TAVILY_API_KEY = os.getenv("TAVILY_API_KEY", "")
-GITHUB_PAT = os.getenv("GITHUB_PAT", "")
-GITHUB_REPO = os.getenv("GITHUB_REPO", "")
-GITHUB_USERNAME = os.getenv("GITHUB_USERNAME", "")
+TAVILY_API_KEY = config("TAVILY_API_KEY", "")
+GITHUB_PAT = config("GITHUB_PAT", "")
+GITHUB_REPO = config("GITHUB_REPO", "")
+GITHUB_USERNAME = config("GITHUB_USERNAME", "")
 
 # -- Debugging and Logging Configurations --
-LOCAL_DEBUG = os.getenv("LOCAL_DEBUG", "0") == "1"
-LOG_LEVEL = os.getenv("LOG_LEVEL", "DEBUG")
+LOCAL_DEBUG = config("LOCAL_DEBUG", True)
+LOG_LEVEL = config("LOG_LEVEL", "DEBUG")
+LOGGING_DIR = config("LOGGING_DIR", "logs")
 
-OTL_SERVICE_NAME = os.getenv("OTL_SERVICE_NAME", "otel-flock")
-JAEGER_ENDPOINT = os.getenv(
+OTEL_SERVICE_NAME = config("OTL_SERVICE_NAME", "otel-flock")
+JAEGER_ENDPOINT = config(
     "JAEGER_ENDPOINT", "http://localhost:14268/api/traces"
 )  # Default gRPC endpoint for Jaeger
-JAEGER_TRANSPORT = os.getenv(
+JAEGER_TRANSPORT = config(
     "JAEGER_TRANSPORT", "http"
 ).lower()  # Options: "grpc" or "http"
+OTEL_SQL_DATABASE_NAME = config("OTEL_SQL_DATABASE", "flock_events.db")
+OTEL_FILE_NAME = config("OTEL_FILE_NAME", "flock_events.jsonl")
+OTEL_ENABLE_SQL = config("OTEL_ENABLE_SQL", True)
+OTEL_ENABLE_FILE = config("OTEL_ENABLE_FILE", True)
+OTEL_ENABLE_JAEGER = config("OTEL_ENABLE_JAEGER", True)
 
 
-TELEMETRY = TelemetryConfig(OTL_SERVICE_NAME, JAEGER_ENDPOINT, JAEGER_TRANSPORT)
+TELEMETRY = TelemetryConfig(
+    OTEL_SERVICE_NAME,
+    JAEGER_ENDPOINT,
+    JAEGER_TRANSPORT,
+    LOGGING_DIR,
+    OTEL_FILE_NAME,
+    OTEL_SQL_DATABASE_NAME,
+    OTEL_ENABLE_JAEGER,
+    OTEL_ENABLE_FILE,
+    OTEL_ENABLE_SQL,
+)
+TELEMETRY.setup_tracing()

flock/core/flock.py

@@ -5,7 +5,7 @@ import uuid
 from typing import TypeVar
 
 from opentelemetry import trace
-from rich.prompt import Prompt
+from opentelemetry.baggage import get_baggage, set_baggage
 
 from flock.core.context.context import FlockContext
 from flock.core.context.context_manager import initialize_context
@@ -63,6 +63,11 @@ class Flock:
                 enable_logging=enable_logging,
             )
             logger.enable_logging = enable_logging
+            session_id = get_baggage("session_id")
+            if not session_id:
+                session_id = str(uuid.uuid4())
+            set_baggage("session_id", session_id)
+            span.set_attribute("session_id", get_baggage("session_id"))
 
             display_banner()
 
@@ -193,12 +198,16 @@ class Flock:
                     run_id = f"{start_agent.name}_{uuid.uuid4().hex[:4]}"
                     logger.debug("Generated run ID", run_id=run_id)
 
+                set_baggage("run_id", run_id)
+
                 # TODO - Add a check for required input keys
                 input_keys = top_level_to_keys(start_agent.input)
                 for key in input_keys:
                     if key.startswith("flock."):
                         key = key[6:]  # Remove the "flock." prefix
                     if key not in input:
+                        from rich.prompt import Prompt
+
                         input[key] = Prompt.ask(
                             f"Please enter {key} for {start_agent.name}"
                         )

flock/core/logging/logging.py

@@ -1,6 +1,5 @@
 # File: src/flock/core/logging.py
-"""A unified logging module for Flock that works both in local/worker contexts
-and inside Temporal workflows.
+"""A unified logging module for Flock that works both in local/worker contexts and inside Temporal workflows.
 
 Key points:
   - We always have Temporal imported, so we cannot decide based on import.
@@ -24,6 +23,7 @@ with workflow.unsafe.imports_passed_through():
 
 def in_workflow_context() -> bool:
     """Returns True if this code is running inside a Temporal workflow context.
+
     It does this by attempting to call workflow.info() and returning True
     if successful. Otherwise, it returns False.
     """
@@ -31,10 +31,7 @@ def in_workflow_context() -> bool:
         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.
-        if hasattr(workflow.info(), "is_replaying"):
-            return True
-        else:
-            return False
+        return bool(hasattr(workflow.info(), "is_replaying"))
     except Exception:
         return False
 
@@ -67,22 +64,24 @@ loguru_logger.add(
 
 # Define a dummy logger that does nothing
 class DummyLogger:
-    def debug(self, *args, **kwargs):
+    """A dummy logger that does nothing when called."""
+
+    def debug(self, *args, **kwargs):  # noqa: D102
         pass
 
-    def info(self, *args, **kwargs):
+    def info(self, *args, **kwargs):  # noqa: D102
         pass
 
-    def warning(self, *args, **kwargs):
+    def warning(self, *args, **kwargs):  # noqa: D102
         pass
 
-    def error(self, *args, **kwargs):
+    def error(self, *args, **kwargs):  # noqa: D102
         pass
 
-    def exception(self, *args, **kwargs):
+    def exception(self, *args, **kwargs):  # noqa: D102
         pass
 
-    def success(self, *args, **kwargs):
+    def success(self, *args, **kwargs):  # noqa: D102
         pass
 
 
@@ -92,7 +91,7 @@ dummy_logger = DummyLogger()
 class FlockLogger:
     """A unified logger that selects the appropriate logging mechanism based on context.
 
-    - If running in a workflow context, it uses Temporal's built‑in logger.
+    - If running in a workflow context, it uses Temporal's built-in logger.
       Additionally, if workflow.info().is_replaying is True, it suppresses debug/info/warning logs.
     - Otherwise, it uses Loguru.
     """
@@ -114,22 +113,22 @@ class FlockLogger:
             trace_id=get_current_trace_id(),
         )
 
-    def debug(self, message: str, *args, **kwargs):
+    def debug(self, message: str, *args, **kwargs):  # noqa: D102
         self._get_logger().debug(message, *args, **kwargs)
 
-    def info(self, message: str, *args, **kwargs):
+    def info(self, message: str, *args, **kwargs):  # noqa: D102
         self._get_logger().info(message, *args, **kwargs)
 
-    def warning(self, message: str, *args, **kwargs):
+    def warning(self, message: str, *args, **kwargs):  # noqa: D102
         self._get_logger().warning(message, *args, **kwargs)
 
-    def error(self, message: str, *args, **kwargs):
+    def error(self, message: str, *args, **kwargs):  # noqa: D102
         self._get_logger().error(message, *args, **kwargs)
 
-    def exception(self, message: str, *args, **kwargs):
+    def exception(self, message: str, *args, **kwargs):  # noqa: D102
         self._get_logger().exception(message, *args, **kwargs)
 
-    def success(self, message: str, *args, **kwargs):
+    def success(self, message: str, *args, **kwargs):  # noqa: D102
         self._get_logger().success(message, *args, **kwargs)
 
 

flock/core/logging/span_middleware/baggage_span_processor.py

@@ -0,0 +1,31 @@
+from opentelemetry.baggage import get_baggage
+from opentelemetry.sdk.trace import SpanProcessor
+
+
+class BaggageAttributeSpanProcessor(SpanProcessor):
+    """A custom span processor that, on span start, inspects the baggage items from the parent context
+    and attaches specified baggage keys as attributes on the span.
+    """
+
+    def __init__(self, baggage_keys=None):
+        # baggage_keys: list of baggage keys to attach to spans (e.g. ["session_id", "run_id"])
+        if baggage_keys is None:
+            baggage_keys = []
+        self.baggage_keys = baggage_keys
+
+    def on_start(self, span, parent_context):
+        # For each desired key, look up its value in the parent context baggage and set it as an attribute.
+        for key in self.baggage_keys:
+            value = get_baggage(key, context=parent_context)
+            if value is not None:
+                span.set_attribute(key, value)
+
+    def on_end(self, span):
+        # No action required on span end for this processor.
+        pass
+
+    def shutdown(self):
+        pass
+
+    def force_flush(self, timeout_millis: int = 30000):
+        pass

flock/core/logging/telemetry.py

@@ -1,17 +1,25 @@
 """This module sets up OpenTelemetry tracing for a service."""
 
+import sys
+
 from opentelemetry import trace
 from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import (
-    BatchSpanProcessor,
-)
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+from temporalio import workflow
 
-from flock.core.logging.telemetry_exporter.file_span import FileSpanExporter
-from flock.core.logging.telemetry_exporter.sqllite_span import (
-    SQLiteSpanExporter,
+from flock.core.logging.span_middleware.baggage_span_processor import (
+    BaggageAttributeSpanProcessor,
 )
 
+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,
+    )
+
 
 class TelemetryConfig:
     """This configuration class sets up OpenTelemetry tracing.
@@ -26,11 +34,15 @@ class TelemetryConfig:
     def __init__(
         self,
         service_name: str,
-        jaeger_endpoint: str = None,
+        jaeger_endpoint: str | None = None,
         jaeger_transport: str = "grpc",
-        file_export_path: str = None,
-        sqlite_db_path: str = None,
-        batch_processor_options: dict = None,
+        local_logging_dir: str | None = None,
+        file_export_name: str | None = None,
+        sqlite_db_name: str | None = None,
+        enable_jaeger: bool = True,
+        enable_file: bool = True,
+        enable_sql: bool = True,
+        batch_processor_options: dict | None = None,
     ):
         """:param service_name: Name of your service.
 
@@ -42,11 +54,16 @@ class TelemetryConfig:
         self.service_name = service_name
         self.jaeger_endpoint = jaeger_endpoint
         self.jaeger_transport = jaeger_transport
-        self.file_export_path = file_export_path
-        self.sqlite_db_path = sqlite_db_path
+        self.file_export_name = file_export_name
+        self.sqlite_db_name = sqlite_db_name
+        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
 
     def setup_tracing(self):
+        """Set up OpenTelemetry tracing with the specified exporters."""
         # Create a Resource with the service name.
         resource = Resource(attributes={"service.name": self.service_name})
         provider = TracerProvider(resource=resource)
@@ -55,8 +72,8 @@ class TelemetryConfig:
         # List to collect our span processors.
         span_processors = []
 
-        # If a Jaeger endpoint is specified, add the Jaeger gRPC exporter.
-        if self.jaeger_endpoint:
+        # If a Jaeger endpoint is specified, add the Jaeger exporter.
+        if self.jaeger_endpoint and self.enable_jaeger:
             if self.jaeger_transport == "grpc":
                 from opentelemetry.exporter.jaeger.proto.grpc import (
                     JaegerExporter,
@@ -77,33 +94,44 @@ class TelemetryConfig:
                     "Invalid JAEGER_TRANSPORT specified. Use 'grpc' or 'http'."
                 )
 
-            span_processors.append(
-                BatchSpanProcessor(
-                    jaeger_exporter, **self.batch_processor_options
-                )
-            )
+            span_processors.append(SimpleSpanProcessor(jaeger_exporter))
 
         # If a file path is provided, add the custom file exporter.
-        if self.file_export_path:
-            file_exporter = FileSpanExporter(self.file_export_path)
-            span_processors.append(
-                BatchSpanProcessor(
-                    file_exporter, **self.batch_processor_options
-                )
+        if self.file_export_name and self.enable_file:
+            file_exporter = FileSpanExporter(
+                self.local_logging_dir, self.file_export_name
             )
+            span_processors.append(SimpleSpanProcessor(file_exporter))
 
-        # If a SQLite database path is provided, add the custom SQLite exporter.
-        if self.sqlite_db_path:
-            sqlite_exporter = SQLiteSpanExporter(self.sqlite_db_path)
-            span_processors.append(
-                BatchSpanProcessor(
-                    sqlite_exporter, **self.batch_processor_options
-                )
+        # 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
             )
+            span_processors.append(SimpleSpanProcessor(sqlite_exporter))
 
         # Register all span processors with the provider.
         for processor in span_processors:
             provider.add_span_processor(processor)
 
-        # Return a tracer instance.
-        return trace.get_tracer(__name__)
+        provider.add_span_processor(
+            BaggageAttributeSpanProcessor(baggage_keys=["session_id", "run_id"])
+        )
+
+        sys.excepthook = self.log_exception_to_otel
+
+    def log_exception_to_otel(self, exc_type, exc_value, exc_traceback):
+        """Log unhandled exceptions to OpenTelemetry."""
+        if issubclass(exc_type, KeyboardInterrupt):
+            # Allow normal handling of KeyboardInterrupt
+            sys.__excepthook__(exc_type, exc_value, exc_traceback)
+            return
+
+        # Use OpenTelemetry to record the exception
+        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))
+            )

flock/core/logging/telemetry_exporter/base_exporter.py

@@ -0,0 +1,38 @@
+"""Base class for custom OpenTelemetry exporters."""
+
+from abc import ABC, abstractmethod
+
+from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
+
+
+class TelemetryExporter(SpanExporter, ABC):
+    """Base class for custom OpenTelemetry exporters."""
+
+    def __init__(self):
+        """Base class for custom OpenTelemetry exporters."""
+        super().__init__()
+
+    def _export(self, spans):
+        """Forward spans to the Jaeger exporter."""
+        try:
+            result = self.export(spans)
+            if result is None:
+                return SpanExportResult.SUCCESS
+            return result
+        except Exception:
+            return SpanExportResult.FAILURE
+        finally:
+            self.shutdown()
+
+    @abstractmethod
+    def export(self, spans) -> SpanExportResult | None:
+        """Export spans to the configured backend.
+
+        To be implemented by subclasses.
+        """
+        raise NotImplementedError("Subclasses must implement the export method")
+
+    @abstractmethod
+    def shutdown(self):
+        """Cleanup resources, if any. Optional for subclasses."""
+        pass

flock/core/logging/telemetry_exporter/file_exporter.py

@@ -0,0 +1,85 @@
+"""A simple exporter that writes span data as JSON lines into a file."""
+
+import json
+
+from opentelemetry.sdk.trace.export import SpanExportResult
+from opentelemetry.trace import Status, StatusCode
+from temporalio import workflow
+
+from flock.core.logging.telemetry_exporter.base_exporter import (
+    TelemetryExporter,
+)
+
+with workflow.unsafe.imports_passed_through():
+    from pathlib import Path
+
+
+class FileSpanExporter(TelemetryExporter):
+    """A simple exporter that writes span data as JSON lines into a file."""
+
+    def __init__(self, dir: str, file_path: str = "flock_events.jsonl"):
+        """Initialize the exporter with a file path."""
+        super().__init__()
+        self.telemetry_path = Path(dir)
+        self.telemetry_path.mkdir(parents=True, exist_ok=True)
+        self.file_path = self.telemetry_path.joinpath(file_path).__str__()
+
+    def _span_to_json(self, span):
+        """Convert a ReadableSpan to a JSON-serializable dict."""
+        context = span.get_span_context()
+        status = span.status or Status(StatusCode.UNSET)
+
+        return {
+            "name": span.name,
+            "context": {
+                "trace_id": format(context.trace_id, "032x"),
+                "span_id": format(context.span_id, "016x"),
+                "trace_flags": context.trace_flags,
+                "trace_state": str(context.trace_state),
+            },
+            "kind": span.kind.name if span.kind else None,
+            "start_time": span.start_time,
+            "end_time": span.end_time,
+            "status": {
+                "status_code": status.status_code.name,
+                "description": status.description,
+            },
+            "attributes": dict(span.attributes or {}),
+            "events": [
+                {
+                    "name": event.name,
+                    "timestamp": event.timestamp,
+                    "attributes": dict(event.attributes or {}),
+                }
+                for event in span.events
+            ],
+            "links": [
+                {
+                    "context": {
+                        "trace_id": format(link.context.trace_id, "032x"),
+                        "span_id": format(link.context.span_id, "016x"),
+                    },
+                    "attributes": dict(link.attributes or {}),
+                }
+                for link in span.links
+            ],
+            "resource": {
+                attr_key: attr_value
+                for attr_key, attr_value in span.resource.attributes.items()
+            },
+        }
+
+    def export(self, spans):
+        """Write spans to a log file."""
+        try:
+            with open(self.file_path, "a") as f:
+                for span in spans:
+                    json_span = self._span_to_json(span)
+                    f.write(f"{json.dumps(json_span)}\n")
+            return SpanExportResult.SUCCESS
+        except Exception:
+            return SpanExportResult.FAILURE
+
+    def shutdown(self) -> None:
+        # Nothing special needed on shutdown.
+        pass

flock/core/logging/telemetry_exporter/sqlite_exporter.py

@@ -0,0 +1,103 @@
+"""Exporter for storing OpenTelemetry spans in SQLite."""
+
+import json
+import sqlite3
+from pathlib import Path
+from typing import Any
+
+from opentelemetry.sdk.trace.export import SpanExportResult
+
+from flock.core.logging.telemetry_exporter.base_exporter import (
+    TelemetryExporter,
+)
+
+
+class SqliteTelemetryExporter(TelemetryExporter):
+    """Exporter for storing OpenTelemetry spans in SQLite."""
+
+    def __init__(self, dir: str, db_path: str = "flock_events.db"):
+        """Initialize the SQLite exporter.
+
+        Args:
+            db_path: Path to the SQLite database file
+        """
+        super().__init__()
+        self.telemetry_path = Path(dir)
+        self.telemetry_path.mkdir(parents=True, exist_ok=True)
+        # Create an absolute path to the database file:
+        self.db_path = self.telemetry_path.joinpath(db_path).resolve().__str__()
+        # Use the absolute path when connecting:
+        self.conn = sqlite3.connect(self.db_path, check_same_thread=False)
+        self._initialize_database()
+
+    def _initialize_database(self):
+        """Set up the SQLite database schema."""
+        cursor = self.conn.cursor()
+        cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS spans (
+                id TEXT PRIMARY KEY,
+                name TEXT,
+                trace_id TEXT,
+                span_id TEXT,
+                start_time INTEGER,
+                end_time INTEGER,
+                attributes TEXT,
+                status TEXT
+            )
+            """
+        )
+        self.conn.commit()
+
+    def _convert_attributes(self, attributes: dict[str, Any]) -> str:
+        """Convert span attributes to a JSON string.
+
+        Args:
+            attributes: Dictionary of span attributes
+
+        Returns:
+            JSON string representation of attributes
+        """
+        # Convert attributes to a serializable format
+        serializable_attrs = {}
+        for key, value in attributes.items():
+            # Convert complex types to strings if needed
+            if isinstance(value, dict | list | tuple):
+                serializable_attrs[key] = json.dumps(value)
+            else:
+                serializable_attrs[key] = str(value)
+        return json.dumps(serializable_attrs)
+
+    def export(self, spans) -> SpanExportResult:
+        """Export spans to SQLite."""
+        try:
+            cursor = self.conn.cursor()
+            for span in spans:
+                span_id = format(span.context.span_id, "016x")
+                trace_id = format(span.context.trace_id, "032x")
+                cursor.execute(
+                    """
+                    INSERT OR REPLACE INTO spans 
+                    (id, name, trace_id, span_id, start_time, end_time, attributes, status)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                    """,
+                    (
+                        span_id,
+                        span.name,
+                        trace_id,
+                        span_id,
+                        span.start_time,
+                        span.end_time,
+                        self._convert_attributes(span.attributes),
+                        str(span.status),
+                    ),
+                )
+            self.conn.commit()
+            return SpanExportResult.SUCCESS
+        except Exception as e:
+            print("Error exporting spans to SQLite:", e)
+            return SpanExportResult.FAILURE
+
+    def shutdown(self) -> None:
+        """Cleanup resources."""
+        pass

flock/core/logging/trace_and_logged.py

@@ -1,3 +1,5 @@
+"""A decorator that wraps a function in an OpenTelemetry span and logs its inputs, outputs, and exceptions."""
+
 import functools
 import inspect
 
@@ -10,7 +12,9 @@ tracer = trace.get_tracer(__name__)
 
 
 def traced_and_logged(func):
-    """A decorator that wraps a function in an OpenTelemetry span and logs its inputs,
+    """A decorator that wraps a function in an OpenTelemetry span.
+
+    and logs its inputs,
     outputs, and exceptions. Supports both synchronous and asynchronous functions.
     """
     if inspect.iscoroutinefunction(func):

flock/platform/docker_tools.py

@@ -0,0 +1,49 @@
+import subprocess
+import time
+
+
+def _check_docker_running():
+    """Check if Docker is running by calling 'docker info'."""
+    try:
+        result = subprocess.run(
+            ["docker", "info"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        return result.returncode == 0
+    except Exception:
+        return False
+
+
+def _start_docker():
+    """Attempt to start Docker.
+    This example first tries 'systemctl start docker' and then 'service docker start'.
+    Adjust as needed for your environment.
+    """
+    try:
+        print("Attempting to start Docker...")
+        result = subprocess.run(
+            ["sudo", "systemctl", "start", "docker"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        if result.returncode != 0:
+            result = subprocess.run(
+                ["sudo", "service", "docker", "start"],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+            )
+        # Give Docker a moment to start.
+        time.sleep(3)
+        if _check_docker_running():
+            print("Docker is now running.")
+            return True
+        else:
+            print("Docker did not start successfully.")
+            return False
+    except Exception as e:
+        print(f"Exception when trying to start Docker: {e}")
+        return False

flock/platform/jaeger_install.py

@@ -0,0 +1,86 @@
+import socket
+import subprocess
+from urllib.parse import urlparse
+
+
+class JaegerInstaller:
+    jaeger_endpoint: str = None
+    jaeger_transport: str = "grpc"
+
+    def _check_jaeger_running(self):
+        """Check if Jaeger is reachable by attempting a socket connection.
+        For HTTP transport, we parse the URL; for gRPC, we expect "host:port".
+        """
+        try:
+            if self.jaeger_transport == "grpc":
+                host, port = self.jaeger_endpoint.split(":")
+                port = int(port)
+            elif self.jaeger_transport == "http":
+                parsed = urlparse(self.jaeger_endpoint)
+                host = parsed.hostname
+                port = parsed.port if parsed.port else 80
+            else:
+                return False
+
+            # Try connecting to the host and port.
+            with socket.create_connection((host, port), timeout=3):
+                return True
+        except Exception:
+            return False
+
+    def _is_jaeger_container_running(self):
+        """Check if a Jaeger container (using the official all-in-one image) is running.
+        This uses 'docker ps' to filter for containers running the Jaeger image.
+        """
+        try:
+            result = subprocess.run(
+                [
+                    "docker",
+                    "ps",
+                    "--filter",
+                    "ancestor=jaegertracing/all-in-one:latest",
+                    "--format",
+                    "{{.ID}}",
+                ],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+            )
+            return bool(result.stdout.strip())
+        except Exception:
+            return False
+
+    def _provision_jaeger_container(self):
+        """Provision a Jaeger container using Docker."""
+        try:
+            print("Provisioning Jaeger container using Docker...")
+            result = subprocess.run(
+                [
+                    "docker",
+                    "run",
+                    "-d",
+                    "--name",
+                    "jaeger",
+                    "-p",
+                    "16686:16686",
+                    "-p",
+                    "14250:14250",
+                    "-p",
+                    "14268:14268",
+                    "jaegertracing/all-in-one:latest",
+                ],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+            )
+            if result.returncode == 0:
+                print("Jaeger container started successfully.")
+                return True
+            else:
+                print(
+                    f"Failed to start Jaeger container. Error: {result.stderr}"
+                )
+                return False
+        except Exception as e:
+            print(f"Exception when provisioning Jaeger container: {e}")
+            return False

{flock_core-0.2.4.dist-info → flock_core-0.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.2.4
+Version: 0.2.5
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE
@@ -11,6 +11,7 @@ Requires-Python: >=3.10
 Requires-Dist: cloudpickle>=3.1.1
 Requires-Dist: devtools>=0.12.2
 Requires-Dist: dspy==2.5.42
+Requires-Dist: duckduckgo-search>=7.3.2
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: msgpack>=1.1.0
@@ -22,6 +23,7 @@ Requires-Dist: opentelemetry-instrumentation-logging>=0.51b0
 Requires-Dist: opentelemetry-sdk>=1.30.0
 Requires-Dist: pydantic>=2.10.5
 Requires-Dist: python-box>=7.3.2
+Requires-Dist: python-decouple>=3.8
 Requires-Dist: rich>=13.9.4
 Requires-Dist: temporalio>=1.9.0
 Requires-Dist: toml>=0.10.2

{flock_core-0.2.4.dist-info → flock_core-0.2.5.dist-info}/RECORD

@@ -1,7 +1,7 @@
-flock/__init__.py,sha256=uJxXAxt0def69cccAAdLjBxQOFXVRO72RE82hJnODSw,108
-flock/config.py,sha256=hul_Vmgl8w5a_4YNfg3Mvll3iVEkjiR5At9D0WsVesw,1006
+flock/__init__.py,sha256=P175tsTOByIhw_CIeMAybUEggKhtoSrc8a0gKotBJfo,177
+flock/config.py,sha256=dyLqNng9ETTEx3CRCkz5N4g62Nu4ygPA6uQKEdbSgag,1499
 flock/core/__init__.py,sha256=0Xq_txurlxxjKGXjRn6GNJusGTiBcd7zw2eF0L7JyuU,183
-flock/core/flock.py,sha256=Iw7Frmz2aZheApxi2KSjsX7gA8ZcemzXhfKXeQdtY0w,9438
+flock/core/flock.py,sha256=0NC-J_ZCojwWDepI6rbX-9jG_Hr2AKgY43ieijhD8DU,9820
 flock/core/flock_agent.py,sha256=59qQ7ohOy2lc1KjI6SV7IcrqYL86ofAhq32pZGgk6eA,27761
 flock/core/context/context.py,sha256=jH06w4C_O5CEL-YxjX_x_dmgLe9Rcllnn1Ebs0dvwaE,6171
 flock/core/context/context_manager.py,sha256=qMySVny_dbTNLh21RHK_YT0mNKIOrqJDZpi9ZVdBsxU,1103
@@ -9,17 +9,19 @@ flock/core/context/context_vars.py,sha256=0Hn6fM2iNc0_jIIU0B7KX-K2o8qXqtZ5EYtwuj
 flock/core/execution/local_executor.py,sha256=O_dgQ_HJPCp97ghdEoDSNDIiaYkogrUS0G2FfK04RRc,973
 flock/core/execution/temporal_executor.py,sha256=ai6ikr9rEiN2Kc-208OalxtfqL_FTt_UaH6a--oEkJM,2010
 flock/core/logging/__init__.py,sha256=Q8hp9-1ilPIUIV0jLgJ3_cP7COrea32cVwL7dicPnlM,82
-flock/core/logging/logging.py,sha256=F-FDz9etBXmAIT-fjx3pUfvNXsckgR6ONCMaFZIc4Kw,4619
-flock/core/logging/telemetry.py,sha256=T2CRSiqOWvOsXe-WRsObkkOkrrd6z-BwEYLaBUU2AAM,4017
-flock/core/logging/trace_and_logged.py,sha256=h4YH8s0KjK4tiBdrEZdCLd4fDzMB5-NKwqzrtkWhQw4,1999
+flock/core/logging/logging.py,sha256=dOo_McbAt9_dST9Hr8RTpAGU-MHR_QvskIdmXrSvZRc,4789
+flock/core/logging/telemetry.py,sha256=yEOfEZ3HBFeLCaHZA6QmsRdwZKtmUC6bQtEOTVeRR4o,5314
+flock/core/logging/trace_and_logged.py,sha256=5vNrK1kxuPMoPJ0-QjQg-EDJL1oiEzvU6UNi6X8FiMs,2117
 flock/core/logging/formatters/base_formatter.py,sha256=CyG-X2NWq8sqEhFEO2aG7Mey5tVkIzoWiihW301_VIo,1023
 flock/core/logging/formatters/formatter_factory.py,sha256=hmH-NpCESHkioX0GBQ5CuQR4axyIXnSRWwAZCHylx6Q,1283
 flock/core/logging/formatters/pprint_formatter.py,sha256=tTm2WhwlCw-SX2Ouci5I9U_HVgxNGY5SSnzB9HZh8bg,692
 flock/core/logging/formatters/rich_formatters.py,sha256=h1FD0_cIdQBQ8P2x05XhgD1cmmP80IBNVT5jb3cAV9M,4776
 flock/core/logging/formatters/theme_builder.py,sha256=1RUEwPIDfCjwTapbK1liasA5SdukOn7YwbZ4H4j1WkI,17364
 flock/core/logging/formatters/themed_formatter.py,sha256=CbxmqUC7zkLzyIxngk-3dcpQ6vxPR6zaDNA2TAMitCI,16714
-flock/core/logging/telemetry_exporter/file_span.py,sha256=e4hr4D7tC9j4KT7JZBuZU0YxQCdHKADpXNeUNEwggN4,1294
-flock/core/logging/telemetry_exporter/sqllite_span.py,sha256=9bqxHt1mDQGyhKxA9dON5xDi_6FMOfBSdrU_zWV0xv4,2107
+flock/core/logging/span_middleware/baggage_span_processor.py,sha256=gJfRl8FeB6jdtghTaRHCrOaTo4fhPMRKgjqtZj-8T48,1118
+flock/core/logging/telemetry_exporter/base_exporter.py,sha256=rQJJzS6q9n2aojoSqwCnl7ZtHrh5LZZ-gkxUuI5WfrQ,1124
+flock/core/logging/telemetry_exporter/file_exporter.py,sha256=nKAjJSZtA7FqHSTuTiFtYYepaxOq7l1rDvs8U8rSBlA,3023
+flock/core/logging/telemetry_exporter/sqlite_exporter.py,sha256=CDsiMb9QcqeXelZ6ZqPSS56ovMPGqOu6whzBZRK__Vg,3498
 flock/core/mixin/dspy_integration.py,sha256=oT5YfXxPhHkMCuwhXoppBAYBGePUAKse7KebGSM-bq0,6880
 flock/core/mixin/prompt_parser.py,sha256=eOqI-FK3y17gVqpc_y5GF-WmK1Jv8mFlkZxTcgweoxI,5121
 flock/core/registry/agent_registry.py,sha256=QHdr3Cb-32PEdz8jFCIZSH9OlfpRwAJMtSRpHCWJDq4,4889
@@ -28,6 +30,8 @@ flock/core/tools/dev_tools/github.py,sha256=6ya2_eN-qITV3b_pYP24jQC3X4oZbRY5GKh1
 flock/core/util/cli_helper.py,sha256=aHLKjl5JBLIczLzjYeUcGQlVQRlypunxV2TYeAFX0KE,1030
 flock/core/util/input_resolver.py,sha256=OesGqX2Dld8myL9Qz04mmxLqoYqOSQC632pj1EMk9Yk,5456
 flock/core/util/serializable.py,sha256=SymJ0YrjBx48mOBItYSqoRpKuzIc4vKWRS6ScTzre7s,2573
+flock/platform/docker_tools.py,sha256=fpA7-6rJBjPOUBLdQP4ny2QPgJ_042nmqRn5GtKnoYw,1445
+flock/platform/jaeger_install.py,sha256=MyOMJQx4TQSMYvdUJxfiGSo3YCtsfkbNXcAcQ9bjETA,2898
 flock/themes/3024-day.toml,sha256=uOVHqEzSyHx0WlUk3D0lne4RBsNBAPCTy3C58yU7kEY,667
 flock/themes/3024-night.toml,sha256=qsXUwd6ZYz6J-R129_Ao2TKlvvK60svhZJJjB5c8Tfo,1667
 flock/themes/aardvark-blue.toml,sha256=Px1qevE6J1ZAc_jAqF_FX674KdIv_3pAYNKmmvDxIbE,1672
@@ -369,7 +373,8 @@ flock/workflow/activities.py,sha256=YEg-Gr8kzVsxWsmsZguIVhX2XwMRvhZ2OlnsJoG5g_A,
 flock/workflow/agent_activities.py,sha256=NhBZscflEf2IMfSRa_pBM_TRP7uVEF_O0ROvWZ33eDc,963
 flock/workflow/temporal_setup.py,sha256=VWBgmBgfTBjwM5ruS_dVpA5AVxx6EZ7oFPGw4j3m0l0,1091
 flock/workflow/workflow.py,sha256=I9MryXW_bqYVTHx-nl2epbTqeRy27CAWHHA7ZZA0nAk,1696
-flock_core-0.2.4.dist-info/METADATA,sha256=VztTdTQKj4pIiPnSearGjlMDmPA_1o0Nak_EefDzs4o,11488
-flock_core-0.2.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flock_core-0.2.4.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
-flock_core-0.2.4.dist-info/RECORD,,
+flock_core-0.2.5.dist-info/METADATA,sha256=T9Yd-0aEUNgHlQnQp64zeDIkDgAsQRoPMF3WnBLUgCk,11564
+flock_core-0.2.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flock_core-0.2.5.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
+flock_core-0.2.5.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
+flock_core-0.2.5.dist-info/RECORD,,

flock_core-0.2.5.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+flock = flock:main

flock/core/logging/telemetry_exporter/file_span.py

@@ -1,37 +0,0 @@
-import json
-
-from opentelemetry.sdk.trace.export import (
-    SpanExporter,
-    SpanExportResult,
-)
-
-
-class FileSpanExporter(SpanExporter):
-    """A simple exporter that writes span data as JSON lines into a file."""
-
-    def __init__(self, file_path: str):
-        self.file_path = file_path
-
-    def export(self, spans) -> SpanExportResult:
-        try:
-            with open(self.file_path, "a") as f:
-                for span in spans:
-                    # Create a dictionary representation of the span.
-                    span_dict = {
-                        "name": span.name,
-                        "trace_id": format(span.context.trace_id, "032x"),
-                        "span_id": format(span.context.span_id, "016x"),
-                        "start_time": span.start_time,
-                        "end_time": span.end_time,
-                        "attributes": span.attributes,
-                        "status": str(span.status),
-                    }
-                    f.write(json.dumps(span_dict) + "\n")
-            return SpanExportResult.SUCCESS
-        except Exception as e:
-            print("Error exporting spans to file:", e)
-            return SpanExportResult.FAILURE
-
-    def shutdown(self) -> None:
-        # Nothing special needed on shutdown.
-        pass

flock/core/logging/telemetry_exporter/sqllite_span.py

@@ -1,68 +0,0 @@
-import json
-import sqlite3
-
-from opentelemetry.sdk.trace.export import (
-    SpanExporter,
-    SpanExportResult,
-)
-
-
-class SQLiteSpanExporter(SpanExporter):
-    """A custom exporter that writes span data into a SQLite database."""
-
-    def __init__(self, sqlite_db_path: str):
-        self.sqlite_db_path = sqlite_db_path
-        self.conn = sqlite3.connect(
-            self.sqlite_db_path, check_same_thread=False
-        )
-        self._create_table()
-
-    def _create_table(self):
-        cursor = self.conn.cursor()
-        cursor.execute(
-            """
-            CREATE TABLE IF NOT EXISTS spans (
-                id TEXT PRIMARY KEY,
-                name TEXT,
-                trace_id TEXT,
-                span_id TEXT,
-                start_time INTEGER,
-                end_time INTEGER,
-                attributes TEXT,
-                status TEXT
-            )
-            """
-        )
-        self.conn.commit()
-
-    def export(self, spans) -> SpanExportResult:
-        try:
-            cursor = self.conn.cursor()
-            for span in spans:
-                span_id = format(span.context.span_id, "016x")
-                trace_id = format(span.context.trace_id, "032x")
-                cursor.execute(
-                    """
-                    INSERT OR REPLACE INTO spans 
-                    (id, name, trace_id, span_id, start_time, end_time, attributes, status)
-                    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-                    """,
-                    (
-                        span_id,
-                        span.name,
-                        trace_id,
-                        span_id,
-                        span.start_time,
-                        span.end_time,
-                        json.dumps(span.attributes),
-                        str(span.status),
-                    ),
-                )
-            self.conn.commit()
-            return SpanExportResult.SUCCESS
-        except Exception as e:
-            print("Error exporting spans to SQLite:", e)
-            return SpanExportResult.FAILURE
-
-    def shutdown(self) -> None:
-        self.conn.close()