autobots-devtools-shared-lib 0.3.2__tar.gz → 0.3.4__tar.gz

{autobots_devtools_shared_lib-0.3.2 → autobots_devtools_shared_lib-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autobots-devtools-shared-lib
-Version: 0.3.2
+Version: 0.3.4
 Summary: Shared library functions to be used for all autobots projects
 License: MIT
 Author: Pralhad

{autobots_devtools_shared_lib-0.3.2 → autobots_devtools_shared_lib-0.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "autobots-devtools-shared-lib"
-version = "0.3.2"
+version = "0.3.4"
 description = "Shared library functions to be used for all autobots projects"
 readme = "README.md"
 authors = [

{autobots_devtools_shared_lib-0.3.2 → autobots_devtools_shared_lib-0.3.4}/src/autobots_devtools_shared_lib/common/config/jenkins_config.py

@@ -5,16 +5,28 @@ from __future__ import annotations
 
 from pydantic import BaseModel, Field
 
+from autobots_devtools_shared_lib.common.config.jenkins_constants import (
+    DEFAULT_API_TOKEN_ENV,
+    DEFAULT_MAX_WAIT_SECONDS,
+    DEFAULT_PARAM_REQUIRED,
+    DEFAULT_PARAM_TYPE,
+    DEFAULT_POLL_INTERVAL_SECONDS,
+    DEFAULT_QUEUE_MAX_RETRIES,
+    DEFAULT_QUEUE_RETRY_DELAY_SECONDS,
+    DEFAULT_USERNAME_ENV,
+    DEFAULT_WAIT_FOR_COMPLETION,
+)
+
 
 class JenkinsAuthConfig(BaseModel):
     """Credentials resolved from environment variables at runtime."""
 
     username_env: str = Field(
-        default="JENKINS_USERNAME",
+        default=DEFAULT_USERNAME_ENV,
         description="Name of the env var holding the Jenkins username",
     )
     token_env: str = Field(
-        default="JENKINS_API_TOKEN",
+        default=DEFAULT_API_TOKEN_ENV,
         description="Name of the env var holding the Jenkins API token",
     )
 
@@ -23,23 +35,23 @@ class JenkinsPollingConfig(BaseModel):
     """Controls whether and how long to wait for a triggered build to complete."""
 
     wait_for_completion: bool = Field(
-        default=True,
+        default=DEFAULT_WAIT_FOR_COMPLETION,
         description="Whether to block until the build finishes",
     )
     poll_interval_seconds: int = Field(
-        default=10,
+        default=DEFAULT_POLL_INTERVAL_SECONDS,
         description="Seconds to wait between build-status polls",
     )
     max_wait_seconds: int = Field(
-        default=300,
+        default=DEFAULT_MAX_WAIT_SECONDS,
         description="Maximum seconds to wait before giving up",
     )
     queue_max_retries: int = Field(
-        default=5,
+        default=DEFAULT_QUEUE_MAX_RETRIES,
         description="Max attempts to resolve a build number from the Jenkins queue",
     )
     queue_retry_delay_seconds: int = Field(
-        default=2,
+        default=DEFAULT_QUEUE_RETRY_DELAY_SECONDS,
         description="Seconds to wait between queue-item polls",
     )
 
@@ -48,7 +60,7 @@ class JenkinsParameterConfig(BaseModel):
     """A single parameter that will be forwarded as a query string to Jenkins."""
 
     type: str = Field(
-        default="string",
+        default=DEFAULT_PARAM_TYPE,
         description="Parameter type: 'string', 'boolean', or 'integer'",
     )
     description: str = Field(
@@ -56,7 +68,7 @@ class JenkinsParameterConfig(BaseModel):
         description="LLM-facing hint describing what value to provide",
     )
     required: bool = Field(
-        default=True,
+        default=DEFAULT_PARAM_REQUIRED,
         description="Whether the LLM must always supply this parameter",
     )
 
@@ -64,7 +76,7 @@ class JenkinsParameterConfig(BaseModel):
 class JenkinsPipelineConfig(BaseModel):
     """Configuration for a single Jenkins pipeline entry.
 
-    The framework registers this as a LangChain tool named ``{key}_tool``,
+    The framework registers this as a LangChain tool named ``{key}{TOOL_NAME_SUFFIX}``,
     so pipeline keys in jenkins.yaml should not carry a ``_tool`` suffix.
     """
 

autobots_devtools_shared_lib-0.3.4/src/autobots_devtools_shared_lib/common/config/jenkins_constants.py

@@ -0,0 +1,65 @@
+# ABOUTME: Shared constants for all Jenkins integration files.
+# ABOUTME: Single source of truth for default values, magic numbers, and string literals.
+
+from __future__ import annotations
+
+# ---------------------------------------------------------------------------
+# Authentication defaults
+# ---------------------------------------------------------------------------
+
+DEFAULT_USERNAME_ENV: str = "JENKINS_USERNAME"
+DEFAULT_API_TOKEN_ENV: str = "JENKINS_API_TOKEN"  # noqa: S105
+
+# ---------------------------------------------------------------------------
+# Polling defaults
+# ---------------------------------------------------------------------------
+
+DEFAULT_WAIT_FOR_COMPLETION: bool = True
+DEFAULT_POLL_INTERVAL_SECONDS: int = 10
+DEFAULT_MAX_WAIT_SECONDS: int = 300
+DEFAULT_QUEUE_MAX_RETRIES: int = 5
+DEFAULT_QUEUE_RETRY_DELAY_SECONDS: int = 2
+
+# ---------------------------------------------------------------------------
+# HTTP
+# ---------------------------------------------------------------------------
+
+HTTP_TIMEOUT_SECONDS: int = 30
+QUEUE_INITIAL_DELAY_SECONDS: int = 1
+
+# ---------------------------------------------------------------------------
+# Jenkins API paths / URL segments
+# ---------------------------------------------------------------------------
+
+JENKINS_CONFIG_FILENAME: str = "jenkins.yaml"
+API_JSON_SUFFIX: str = "api/json"
+JOB_URL_SEGMENT: str = "job"
+LAST_BUILD_SEGMENT: str = "lastBuild"
+CONSOLE_LOG_PATH: str = "logText/progressiveText"
+
+# ---------------------------------------------------------------------------
+# URL templates  (use .format(base_url=..., job_name=..., build_number=..., start=...))
+# ---------------------------------------------------------------------------
+
+_BASE_JOB_PREFIX: str = "{base_url}/" + JOB_URL_SEGMENT + "/{job_name}/"
+
+BUILD_STATUS_LATEST_URL: str = _BASE_JOB_PREFIX + LAST_BUILD_SEGMENT + "/" + API_JSON_SUFFIX
+BUILD_STATUS_URL: str = _BASE_JOB_PREFIX + "{build_number}/" + API_JSON_SUFFIX
+CONSOLE_LOG_LATEST_URL: str = (
+    _BASE_JOB_PREFIX + LAST_BUILD_SEGMENT + "/" + CONSOLE_LOG_PATH + "?start={start}"
+)
+CONSOLE_LOG_URL: str = _BASE_JOB_PREFIX + "{build_number}/" + CONSOLE_LOG_PATH + "?start={start}"
+
+# ---------------------------------------------------------------------------
+# Tool naming
+# ---------------------------------------------------------------------------
+
+TOOL_NAME_SUFFIX: str = "_tool"
+ARGS_SCHEMA_SUFFIX: str = "_args"
+
+# ---------------------------------------------------------------------------
+# Parameter config defaults
+# ---------------------------------------------------------------------------
+
+DEFAULT_PARAM_TYPE: str = "string"
+DEFAULT_PARAM_REQUIRED: bool = True

autobots_devtools_shared_lib-0.3.4/src/autobots_devtools_shared_lib/common/config/jenkins_loader.py

@@ -0,0 +1,75 @@
+# ABOUTME: Loads jenkins.yaml from the same config directory as agents.yaml.
+# ABOUTME: Returns None silently when jenkins.yaml is absent (feature is opt-in).
+# ABOUTME: Owns the JenkinsConfig singleton — get_jenkins_config() is the shared access point.
+
+from __future__ import annotations
+
+import yaml
+
+from autobots_devtools_shared_lib.common.config.jenkins_config import JenkinsConfig
+from autobots_devtools_shared_lib.common.config.jenkins_constants import JENKINS_CONFIG_FILENAME
+from autobots_devtools_shared_lib.common.observability.logging_utils import get_logger
+
+logger = get_logger(__name__)
+
+_config: JenkinsConfig | None = None
+_config_loaded: bool = False
+
+
+def set_jenkins_config(config: JenkinsConfig | None) -> None:
+    """Explicitly set the Jenkins config singleton (useful for tests or custom injection)."""
+    global _config, _config_loaded
+    _config = config
+    _config_loaded = True
+
+
+def get_jenkins_config() -> JenkinsConfig | None:
+    """Return the cached JenkinsConfig, loading from disk on the first call.
+
+    Jenkins config is optional — returns None when jenkins.yaml is absent.
+    The result (including None) is cached after the first call so the filesystem
+    is only read once regardless of outcome. Subsequent calls return immediately.
+
+    Raises:
+        yaml.YAMLError: If the file contains invalid YAML (first call only).
+        pydantic.ValidationError: If the YAML structure does not match the schema (first call only).
+    """
+    global _config, _config_loaded
+    if not _config_loaded:
+        set_jenkins_config(_load_jenkins_config())
+    return _config
+
+
+def _load_jenkins_config() -> JenkinsConfig | None:
+    """Load and validate jenkins.yaml from the active config directory.
+
+    Internal implementation — always reads from disk without caching.
+    Use get_jenkins_config() for the cached singleton instead.
+
+    Returns:
+        Validated JenkinsConfig or None if the file does not exist.
+
+    Raises:
+        yaml.YAMLError: If the file contains invalid YAML.
+        pydantic.ValidationError: If the YAML structure does not match the schema.
+    """
+    from autobots_devtools_shared_lib.dynagent.agents.agent_config_utils import get_config_dir
+
+    config_dir = get_config_dir()
+    jenkins_path = config_dir / JENKINS_CONFIG_FILENAME
+
+    if not jenkins_path.exists():
+        logger.debug(
+            f"No jenkins.yaml found at {jenkins_path}; Jenkins tools will not be registered"
+        )
+        return None
+
+    logger.info(f"Loading Jenkins config from {jenkins_path}")
+    with open(jenkins_path) as f:  # noqa: PTH123
+        raw = yaml.safe_load(f)
+
+    config = JenkinsConfig.model_validate(raw["jenkins_config"])
+    logger.info(
+        f"Loaded Jenkins config with {len(config.pipelines)} pipeline(s): {list(config.pipelines)}"
+    )
+    return config

{autobots_devtools_shared_lib-0.3.2 → autobots_devtools_shared_lib-0.3.4}/src/autobots_devtools_shared_lib/common/observability/otel_fastapi.py

@@ -34,14 +34,20 @@ class OtelCaptureConfig:
         ]
 
 
+# Default Langfuse cloud host when LANGFUSE_HOST is not set (same as trace_propagation.py).
+_DEFAULT_LANGFUSE_HOST = "https://cloud.langfuse.com"
+
+
 def _configure_langfuse_otlp() -> bool:
     """If Langfuse keys are set, configure env for OTLP export to Langfuse. Returns True if set."""
     pk = os.getenv("LANGFUSE_PUBLIC_KEY", "").strip()
     sk = os.getenv("LANGFUSE_SECRET_KEY", "").strip()
     if not pk or not sk:
         return False
-    host = os.getenv("LANGFUSE_HOST")
-    endpoint = f"{host}/api/public/otel"
+    host = os.getenv("LANGFUSE_BASE_URL", _DEFAULT_LANGFUSE_HOST).strip()
+    if not host:
+        return False
+    endpoint = f"{host.rstrip('/')}/api/public/otel"
     auth = base64.b64encode(f"{pk}:{sk}".encode()).decode()
     os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"] = endpoint
     os.environ["OTEL_EXPORTER_OTLP_HEADERS"] = f"Authorization=Basic {auth}"
@@ -207,12 +213,12 @@ def _set_span_attributes(
             input_data["body"] = req_truncated["content"]
             input_data["body_size"] = req_truncated["size_bytes"]
 
-            # Extract conversation_id and set as langfuse.session.id
+            # Extract session_id and set as langfuse.session.id
             try:
                 req_json = json.loads(req_body.decode("utf-8"))
-                conversation_id = req_json.get("conversation_id")
-                if conversation_id:
-                    span.set_attribute("langfuse.session.id", str(conversation_id))
+                session_id = req_json.get("session_id")
+                if session_id:
+                    span.set_attribute("langfuse.session.id", str(session_id))
             except (json.JSONDecodeError, UnicodeDecodeError):
                 # Not JSON or invalid UTF-8, skip session linking
                 pass

{autobots_devtools_shared_lib-0.3.2 → autobots_devtools_shared_lib-0.3.4}/src/autobots_devtools_shared_lib/common/observability/trace_propagation.py

@@ -2,7 +2,7 @@
 OpenTelemetry trace propagation helpers for HTTP client calls.
 
 Provides W3C traceparent header injection and session linking for fileserver HTTP calls.
-Reuses Langfuse configuration (LANGFUSE_PUBLIC_KEY, LANGFUSE_SECRET_KEY, LANGFUSE_HOST).
+Reuses Langfuse configuration (LANGFUSE_PUBLIC_KEY, LANGFUSE_SECRET_KEY, LANGFUSE_BASE_URL).
 """
 
 from __future__ import annotations
@@ -11,7 +11,7 @@ import base64
 import os
 import sys
 from contextlib import contextmanager
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from collections.abc import Generator
@@ -43,8 +43,8 @@ def _ensure_tracer_provider() -> bool:
     try:
         # Check if OTEL packages available
         from opentelemetry import trace
-        from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
-            OTLPSpanExporter,  # pyright: ignore[reportMissingImports]
+        from opentelemetry.exporter.otlp.proto.http.trace_exporter import (  # pyright: ignore[reportMissingImports]
+            OTLPSpanExporter,
         )
         from opentelemetry.sdk.resources import Resource
         from opentelemetry.sdk.trace import TracerProvider
@@ -80,7 +80,7 @@ def _ensure_tracer_provider() -> bool:
 
     try:
         # Configure OTLP endpoint (same pattern as otel_fastapi.py)
-        host = os.getenv("LANGFUSE_HOST", "https://cloud.langfuse.com")
+        host = os.getenv("LANGFUSE_BASE_URL", "https://cloud.langfuse.com")
         endpoint = f"{host}/api/public/otel"
         auth = base64.b64encode(f"{pk}:{sk}".encode()).decode()
         os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"] = endpoint
@@ -115,6 +115,35 @@ def _ensure_tracer_provider() -> bool:
     return False
 
 
+def ensure_tracer_provider() -> bool:
+    """Public wrapper — returns True when an OTel tracer provider is ready."""
+    return _ensure_tracer_provider()
+
+
+def otel_span(name: str, kind: str = "SERVER") -> Any:
+    """Return an OTel span context manager, or nullcontext if OTel is unavailable.
+
+    Use this to create a root span that encompasses an entire orchestration step
+    (agent invocation + downstream file I/O) so all child spans share one trace.
+
+    Args:
+        name: Span name shown in Langfuse.
+        kind: OTel SpanKind string — "SERVER" (default) or "CLIENT".
+    """
+    from contextlib import nullcontext
+
+    if not _ensure_tracer_provider():
+        return nullcontext()
+    try:
+        from opentelemetry import trace
+        from opentelemetry.trace import SpanKind
+
+        span_kind = SpanKind.CLIENT if kind == "CLIENT" else SpanKind.SERVER
+        return trace.get_tracer(__name__).start_as_current_span(name, kind=span_kind)
+    except Exception:
+        return nullcontext()
+
+
 @contextmanager
 def traced_http_call(
     operation: str,
@@ -125,6 +154,9 @@ def traced_http_call(
     Context manager that creates an OTEL client span and injects W3C traceparent header.
 
     Links HTTP calls to Langfuse sessions via langfuse.session.id attribute.
+    When the same session_id is used for the parent (e.g. nurture trigger / agent
+    invocation) and for file client calls, Langfuse groups them in the Session view
+    so http.client.readFile / http.client.writeFile appear with the agent trace.
     Gracefully degrades to empty headers if OTEL unavailable.
 
     Args:

autobots_devtools_shared_lib-0.3.4/src/autobots_devtools_shared_lib/common/tools/jenkins_builtin_tools.py

@@ -0,0 +1,35 @@
+# ABOUTME: Thin LangChain agent layer for Jenkins observability tools.
+# ABOUTME: Wraps get_build_status() and get_console_log() from jenkins_builtin_utils as @tools.
+# ABOUTME: All HTTP logic lives in common/utils/jenkins_builtin_utils.py.
+
+from __future__ import annotations
+
+from langchain.tools import tool
+
+from autobots_devtools_shared_lib.common.utils.jenkins_builtin_utils import (
+    get_build_status,
+    get_console_log,
+)
+
+
+@tool
+def get_jenkins_build_status(job_name: str, build_number: int | None = None) -> str:
+    """Get the current status of a Jenkins build.
+
+    Returns a concise string with job name, build number,
+    status (SUCCESS / FAILURE / IN_PROGRESS), and build URL.
+    Omit build_number to check the latest build.
+    """
+    return get_build_status(job_name, build_number)
+
+
+@tool
+def get_jenkins_console_log(job_name: str, build_number: int | None = None, start: int = 0) -> str:
+    """Retrieve the console log output for a Jenkins build.
+
+    Returns the log text from the given byte offset.
+    Use start=0 (default) for the full log.
+    Omit build_number to use the latest build.
+    Useful for diagnosing pipeline failures.
+    """
+    return get_console_log(job_name, build_number, start)

autobots_devtools_shared_lib-0.3.4/src/autobots_devtools_shared_lib/common/tools/jenkins_pipeline_tools.py

@@ -0,0 +1,117 @@
+# ABOUTME: Thin LangChain agent layer — wraps JenkinsPipelineRunner as StructuredTools.
+# ABOUTME: All execution logic lives in common/utils/jenkins_pipeline_utils.py.
+# ABOUTME: register_pipeline_tools() is the single entry point for agent tool registration.
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from langchain_core.tools import StructuredTool
+from pydantic import BaseModel, Field, create_model
+
+from autobots_devtools_shared_lib.common.config.jenkins_constants import (
+    ARGS_SCHEMA_SUFFIX,
+    TOOL_NAME_SUFFIX,
+)
+from autobots_devtools_shared_lib.common.observability.logging_utils import get_logger
+from autobots_devtools_shared_lib.common.tools.jenkins_builtin_tools import (
+    get_jenkins_build_status,
+    get_jenkins_console_log,
+)
+from autobots_devtools_shared_lib.common.utils.jenkins_pipeline_utils import get_pipeline_runner
+
+if TYPE_CHECKING:
+    from autobots_devtools_shared_lib.common.config.jenkins_config import JenkinsPipelineConfig
+
+logger = get_logger(__name__)
+
+_PYTHON_TYPE_MAP: dict[str, type] = {
+    "string": str,
+    "str": str,
+    "boolean": bool,
+    "bool": bool,
+    "integer": int,
+    "int": int,
+    "float": float,
+    "number": float,
+}
+
+
+def _build_args_schema(tool_name: str, pipeline_cfg: JenkinsPipelineConfig) -> type[BaseModel]:
+    """Build a dynamic Pydantic model from a pipeline's parameters.
+
+    Required parameters get a plain Field; optional ones get ``type | None`` with default None.
+    """
+    field_definitions: dict[str, Any] = {}
+    for param_name, param_cfg in pipeline_cfg.parameters.items():
+        py_type = _PYTHON_TYPE_MAP.get(param_cfg.type.lower(), str)
+        if param_cfg.required:
+            field_definitions[param_name] = (py_type, Field(description=param_cfg.description))
+        else:
+            field_definitions[param_name] = (
+                py_type | None,
+                Field(default=None, description=param_cfg.description),
+            )
+    return create_model(f"{tool_name}{ARGS_SCHEMA_SUFFIX}", **field_definitions)
+
+
+def create_jenkins_tools() -> list[Any]:
+    """Generate LangChain StructuredTools from the loaded JenkinsConfig.
+
+    For each entry in ``config.pipelines`` a StructuredTool is created whose
+    name is ``{pipeline_key}_tool`` (e.g. pipeline key ``create_workspace``
+    → tool name ``create_workspace_tool``).
+
+    Config is loaded lazily via get_pipeline_runner() — no explicit config
+    argument needed. Call register_pipeline_tools() as the higher-level entry
+    point which also includes the builtin observability tools.
+
+    Returns:
+        List of pipeline StructuredTools ready for ``register_usecase_tools()``.
+        The builtin observability tools are not included here.
+
+    Raises:
+        RuntimeError: If jenkins.yaml cannot be found.
+    """
+    runner = get_pipeline_runner()
+    tools: list[Any] = []
+
+    for pipeline_name, pipeline_cfg in runner._config.pipelines.items():
+        tool_name = f"{pipeline_name}{TOOL_NAME_SUFFIX}"
+        args_schema = _build_args_schema(tool_name, pipeline_cfg)
+        description = pipeline_cfg.description or f"Trigger Jenkins pipeline: {pipeline_cfg.uri}"
+
+        tools.append(
+            StructuredTool.from_function(
+                func=runner.get_callable(pipeline_name),
+                name=tool_name,
+                description=description,
+                args_schema=args_schema,
+            )
+        )
+        logger.info(f"Registered Jenkins tool '{tool_name}' → {pipeline_cfg.uri}")
+
+    return tools
+
+
+def register_pipeline_tools() -> list[Any]:
+    """Load jenkins.yaml and return all Jenkins tools (pipeline + builtin observability).
+
+    Returns an empty list when jenkins.yaml is absent — Jenkins integration is optional.
+    Config loading and caching is handled internally; no setup required before calling.
+    """
+    try:
+        from autobots_devtools_shared_lib.common.config.jenkins_loader import get_jenkins_config
+
+        if get_jenkins_config() is not None:
+            logger.info("Loading Jenkins pipeline tools")
+            pipeline_tools = create_jenkins_tools()
+            all_tools = [get_jenkins_build_status, get_jenkins_console_log, *pipeline_tools]
+            logger.info(
+                f"Loaded {len(pipeline_tools)} pipeline tool(s) + 2 builtin Jenkins tools"
+                " from jenkins.yaml"
+            )
+            return all_tools
+    except Exception:
+        logger.exception("Failed to load Jenkins pipeline tools — continuing without them")
+    return []

autobots_devtools_shared_lib-0.3.4/src/autobots_devtools_shared_lib/common/utils/jenkins_builtin_utils.py

@@ -0,0 +1,97 @@
+# ABOUTME: Deterministic Jenkins observability utilities — pure Python, no LangChain dependency.
+# ABOUTME: Provides get_build_status() and get_console_log() for direct/deterministic use.
+# ABOUTME: LangChain @tool wrappers live in common/tools/jenkins_builtin_tools.py.
+
+from __future__ import annotations
+
+import requests
+
+from autobots_devtools_shared_lib.common.config.jenkins_constants import (
+    BUILD_STATUS_LATEST_URL,
+    BUILD_STATUS_URL,
+    CONSOLE_LOG_LATEST_URL,
+    CONSOLE_LOG_URL,
+    HTTP_TIMEOUT_SECONDS,
+)
+from autobots_devtools_shared_lib.common.config.jenkins_loader import get_jenkins_config
+from autobots_devtools_shared_lib.common.observability.logging_utils import get_logger
+from autobots_devtools_shared_lib.common.utils.jenkins_http_utils import get_auth
+
+logger = get_logger(__name__)
+
+
+def get_build_status(job_name: str, build_number: int | None = None) -> str:
+    """Get the current status of a Jenkins build.
+
+    Args:
+        job_name: Jenkins job name.
+        build_number: Specific build number; omit to check the latest build.
+
+    Returns:
+        A concise string: ``job=<name> build=<n> status=<STATUS> url=<url>``.
+        Returns an error string if Jenkins is not configured or the request fails.
+    """
+    config = get_jenkins_config()
+    if config is None:
+        return "Error: Jenkins is not configured (jenkins.yaml not found)"
+
+    base_url = config.base_url.rstrip("/")
+    auth = get_auth(config)
+    if build_number is None:
+        api_url = BUILD_STATUS_LATEST_URL.format(base_url=base_url, job_name=job_name)
+    else:
+        api_url = BUILD_STATUS_URL.format(
+            base_url=base_url, job_name=job_name, build_number=build_number
+        )
+
+    logger.info("Getting build status for job='%s' build=%s", job_name, build_number)
+    try:
+        resp = requests.get(api_url, auth=auth, timeout=HTTP_TIMEOUT_SECONDS)
+        resp.raise_for_status()
+        data = resp.json()
+        number = data.get("number")
+        building = data.get("building", False)
+        result = data.get("result")
+        url = data.get("url", "")
+        status = "IN_PROGRESS" if (building or result is None) else str(result).upper()
+    except requests.RequestException as exc:
+        logger.exception("Error getting build status for '%s'", job_name)
+        return f"Error getting build status: {exc}"
+    else:
+        return f"job={job_name} build={number} status={status} url={url}"
+
+
+def get_console_log(job_name: str, build_number: int | None = None, start: int = 0) -> str:
+    """Retrieve the console log output for a Jenkins build.
+
+    Args:
+        job_name: Jenkins job name.
+        build_number: Specific build number; omit to use the latest build.
+        start: Byte offset to start reading from (0 for the full log).
+
+    Returns:
+        Log text as a string.
+        Returns an error string if Jenkins is not configured or the request fails.
+    """
+    config = get_jenkins_config()
+    if config is None:
+        return "Error: Jenkins is not configured (jenkins.yaml not found)"
+
+    base_url = config.base_url.rstrip("/")
+    auth = get_auth(config)
+    if build_number is None:
+        log_url = CONSOLE_LOG_LATEST_URL.format(base_url=base_url, job_name=job_name, start=start)
+    else:
+        log_url = CONSOLE_LOG_URL.format(
+            base_url=base_url, job_name=job_name, build_number=build_number, start=start
+        )
+
+    logger.info("Getting console log for job='%s' build=%s start=%s", job_name, build_number, start)
+    try:
+        resp = requests.get(log_url, auth=auth, timeout=HTTP_TIMEOUT_SECONDS)
+        resp.raise_for_status()
+    except requests.RequestException as exc:
+        logger.exception("Error getting console log for '%s'", job_name)
+        return f"Error getting console log: {exc}"
+    else:
+        return resp.text

{autobots_devtools_shared_lib-0.3.2 → autobots_devtools_shared_lib-0.3.4}/src/autobots_devtools_shared_lib/common/utils/jenkins_http_utils.py

@@ -9,6 +9,13 @@ from typing import TYPE_CHECKING, Any
 
 import requests
 
+from autobots_devtools_shared_lib.common.config.jenkins_constants import (
+    API_JSON_SUFFIX,
+    BUILD_STATUS_URL,
+    HTTP_TIMEOUT_SECONDS,
+    JOB_URL_SEGMENT,
+    QUEUE_INITIAL_DELAY_SECONDS,
+)
 from autobots_devtools_shared_lib.common.observability.logging_utils import get_logger
 
 if TYPE_CHECKING:
@@ -51,13 +58,13 @@ def poll_queue_for_build_number(
         logger.error(msg)
         return {"status": "error", "message": msg, "build_number": None, "build_url": None}
 
-    time.sleep(1)
-    queue_api_url = f"{queue_location}api/json"
+    time.sleep(QUEUE_INITIAL_DELAY_SECONDS)
+    queue_api_url = f"{queue_location}{API_JSON_SUFFIX}"
     logger.info(f"Polling Jenkins queue: {queue_api_url}")
 
     for attempt in range(polling.queue_max_retries):
         try:
-            resp = requests.get(queue_api_url, auth=auth, timeout=30)
+            resp = requests.get(queue_api_url, auth=auth, timeout=HTTP_TIMEOUT_SECONDS)
             resp.raise_for_status()
             data = resp.json()
             executable = data.get("executable")
@@ -106,10 +113,12 @@ def wait_for_build(
 ) -> str:
     """Poll the build API until the result is non-null or the timeout is reached."""
     elapsed = 0
-    api_url = f"{base_url}/job/{job_name}/{build_number}/api/json"
+    api_url = BUILD_STATUS_URL.format(
+        base_url=base_url, job_name=job_name, build_number=build_number
+    )
     while elapsed < polling.max_wait_seconds:
         try:
-            resp = requests.get(api_url, auth=auth, timeout=30)
+            resp = requests.get(api_url, auth=auth, timeout=HTTP_TIMEOUT_SECONDS)
             resp.raise_for_status()
             data = resp.json()
             building = data.get("building", False)
@@ -148,7 +157,7 @@ def extract_job_name_from_url(url: str) -> str:
     """
     parts = [p for p in url.split("/") if p]
     try:
-        job_idx = parts.index("job")
+        job_idx = parts.index(JOB_URL_SEGMENT)
         return parts[job_idx + 1]
     except (ValueError, IndexError):
         return url