airbyte-internal-ops 0.9.1__py3-none-any.whl → 0.10.1__py3-none-any.whl

airbyte_ops_mcp/mcp/prod_db_queries.py

@@ -23,6 +23,7 @@ from airbyte_ops_mcp.prod_db_access.queries import (
     query_connections_by_connector,
     query_connections_by_destination_connector,
     query_connections_by_stream,
+    query_connector_rollouts,
     query_connector_versions,
     query_dataplanes_list,
     query_destination_connection_stats,
@@ -1272,6 +1273,145 @@ def query_prod_connector_connection_stats(
     )
 
 
+# =============================================================================
+# Connector Rollout Models and Tools
+# =============================================================================
+
+
+class ConnectorRolloutInfo(BaseModel):
+    """Information about a connector rollout."""
+
+    rollout_id: str = Field(description="The rollout UUID")
+    actor_definition_id: str = Field(description="The connector definition UUID")
+    state: str = Field(
+        description="Rollout state: initialized, workflow_started, in_progress, "
+        "paused, finalizing, succeeded, errored, failed_rolled_back, canceled"
+    )
+    initial_rollout_pct: int | None = Field(
+        default=None, description="Initial rollout percentage"
+    )
+    current_target_rollout_pct: int | None = Field(
+        default=None, description="Current target rollout percentage"
+    )
+    final_target_rollout_pct: int | None = Field(
+        default=None, description="Final target rollout percentage"
+    )
+    has_breaking_changes: bool = Field(
+        description="Whether the RC has breaking changes"
+    )
+    max_step_wait_time_mins: int | None = Field(
+        default=None, description="Maximum wait time between rollout steps in minutes"
+    )
+    rollout_strategy: str | None = Field(
+        default=None, description="Rollout strategy: manual, automated, overridden"
+    )
+    workflow_run_id: str | None = Field(
+        default=None, description="Temporal workflow run ID"
+    )
+    error_msg: str | None = Field(default=None, description="Error message if errored")
+    failed_reason: str | None = Field(
+        default=None, description="Reason for failure if failed"
+    )
+    paused_reason: str | None = Field(
+        default=None, description="Reason for pause if paused"
+    )
+    tag: str | None = Field(default=None, description="Optional tag for the rollout")
+    created_at: datetime | None = Field(
+        default=None, description="When the rollout was created"
+    )
+    updated_at: datetime | None = Field(
+        default=None, description="When the rollout was last updated"
+    )
+    completed_at: datetime | None = Field(
+        default=None, description="When the rollout completed (if terminal)"
+    )
+    expires_at: datetime | None = Field(
+        default=None, description="When the rollout expires"
+    )
+    rc_docker_image_tag: str | None = Field(
+        default=None, description="Docker image tag of the release candidate"
+    )
+    rc_docker_repository: str | None = Field(
+        default=None, description="Docker repository of the release candidate"
+    )
+    initial_docker_image_tag: str | None = Field(
+        default=None, description="Docker image tag of the initial version"
+    )
+    initial_docker_repository: str | None = Field(
+        default=None, description="Docker repository of the initial version"
+    )
+
+
+def _row_to_connector_rollout_info(row: dict[str, Any]) -> ConnectorRolloutInfo:
+    """Convert a database row to a ConnectorRolloutInfo model."""
+    return ConnectorRolloutInfo(
+        rollout_id=str(row["rollout_id"]),
+        actor_definition_id=str(row["actor_definition_id"]),
+        state=row["state"],
+        initial_rollout_pct=row.get("initial_rollout_pct"),
+        current_target_rollout_pct=row.get("current_target_rollout_pct"),
+        final_target_rollout_pct=row.get("final_target_rollout_pct"),
+        has_breaking_changes=row["has_breaking_changes"],
+        max_step_wait_time_mins=row.get("max_step_wait_time_mins"),
+        rollout_strategy=row.get("rollout_strategy"),
+        workflow_run_id=row.get("workflow_run_id"),
+        error_msg=row.get("error_msg"),
+        failed_reason=row.get("failed_reason"),
+        paused_reason=row.get("paused_reason"),
+        tag=row.get("tag"),
+        created_at=row.get("created_at"),
+        updated_at=row.get("updated_at"),
+        completed_at=row.get("completed_at"),
+        expires_at=row.get("expires_at"),
+        rc_docker_image_tag=row.get("rc_docker_image_tag"),
+        rc_docker_repository=row.get("rc_docker_repository"),
+        initial_docker_image_tag=row.get("initial_docker_image_tag"),
+        initial_docker_repository=row.get("initial_docker_repository"),
+    )
+
+
+@mcp_tool(
+    read_only=True,
+    idempotent=True,
+)
+def query_prod_connector_rollouts(
+    actor_definition_id: Annotated[
+        str | None,
+        Field(description="Connector definition UUID to filter by (optional)"),
+    ] = None,
+    rollout_id: Annotated[
+        str | None,
+        Field(description="Specific rollout UUID to look up (optional)"),
+    ] = None,
+    active_only: Annotated[
+        bool,
+        Field(description="If true, only return active (non-terminal) rollouts"),
+    ] = False,
+    limit: Annotated[
+        int,
+        Field(description="Maximum number of results (default: 100)"),
+    ] = 100,
+) -> list[ConnectorRolloutInfo]:
+    """Query connector rollouts with flexible filtering.
+
+    Returns rollouts based on the provided filters. If no filters are specified,
+    returns all active rollouts. Useful for monitoring rollout status and history.
+
+    Filter behavior:
+    - rollout_id: Returns that specific rollout (ignores other filters)
+    - active_only: Returns only active (non-terminal) rollouts
+    - actor_definition_id: Returns rollouts for that specific connector
+    - No filters: Returns all active rollouts (same as active_only=True)
+    """
+    rows = query_connector_rollouts(
+        actor_definition_id=actor_definition_id,
+        rollout_id=rollout_id,
+        active_only=active_only,
+        limit=limit,
+    )
+    return [_row_to_connector_rollout_info(row) for row in rows]
+
+
 def register_prod_db_query_tools(app: FastMCP) -> None:
     """Register prod DB query tools with the FastMCP app."""
     register_mcp_tools(app, mcp_module=__name__)

airbyte_ops_mcp/mcp/server.py

@@ -33,6 +33,7 @@ from airbyte_ops_mcp.mcp._guidance import MCP_SERVER_INSTRUCTIONS
 from airbyte_ops_mcp.mcp.cloud_connector_versions import (
     register_cloud_connector_version_tools,
 )
+from airbyte_ops_mcp.mcp.connector_rollout import register_connector_rollout_tools
 from airbyte_ops_mcp.mcp.gcp_logs import register_gcp_logs_tools
 from airbyte_ops_mcp.mcp.github_actions import register_github_actions_tools
 from airbyte_ops_mcp.mcp.github_repo_ops import register_github_repo_ops_tools
@@ -117,6 +118,7 @@ def register_server_assets(app: FastMCP) -> None:
     register_github_actions_tools(app)
     register_prerelease_tools(app)
     register_cloud_connector_version_tools(app)
+    register_connector_rollout_tools(app)
     register_prod_db_query_tools(app)
     register_gcp_logs_tools(app)
     register_prompts(app)

airbyte_ops_mcp/prod_db_access/queries.py

@@ -19,6 +19,8 @@ from google.cloud import secretmanager
 from airbyte_ops_mcp.gcp_auth import get_secret_manager_client
 from airbyte_ops_mcp.prod_db_access.db_engine import get_pool
 from airbyte_ops_mcp.prod_db_access.sql import (
+    SELECT_ACTIVE_CONNECTOR_ROLLOUTS,
+    SELECT_ACTIVE_CONNECTOR_ROLLOUTS_BY_DEFINITION,
     SELECT_ACTORS_PINNED_TO_VERSION,
     SELECT_CONNECTIONS_BY_CONNECTOR,
     SELECT_CONNECTIONS_BY_CONNECTOR_AND_ORG,
@@ -26,6 +28,8 @@ from airbyte_ops_mcp.prod_db_access.sql import (
     SELECT_CONNECTIONS_BY_DESTINATION_CONNECTOR_AND_ORG,
     SELECT_CONNECTIONS_BY_SOURCE_CONNECTOR_AND_STREAM,
     SELECT_CONNECTIONS_BY_SOURCE_CONNECTOR_AND_STREAM_AND_ORG,
+    SELECT_CONNECTOR_ROLLOUT_BY_ID,
+    SELECT_CONNECTOR_ROLLOUTS,
     SELECT_CONNECTOR_VERSIONS,
     SELECT_DATAPLANES_LIST,
     SELECT_DESTINATION_CONNECTION_STATS,
@@ -616,3 +620,82 @@ def query_connections_by_stream(
         query_name="SELECT_CONNECTIONS_BY_SOURCE_CONNECTOR_AND_STREAM_AND_ORG",
         gsm_client=gsm_client,
     )
+
+
+def query_connector_rollouts(
+    actor_definition_id: str | None = None,
+    rollout_id: str | None = None,
+    active_only: bool = False,
+    limit: int = 100,
+    *,
+    gsm_client: secretmanager.SecretManagerServiceClient | None = None,
+) -> list[dict[str, Any]]:
+    """Query connector rollouts with flexible filtering.
+
+    This is the unified query function for connector rollouts. Based on the
+    arguments provided, it will:
+    - If rollout_id is provided: Return that specific rollout (as a single-item list)
+    - If active_only is True AND actor_definition_id is provided: Return active rollouts for that connector
+    - If active_only is True: Return all active (non-terminal) rollouts
+    - If actor_definition_id is provided: Return all rollouts for that connector (including terminal)
+    - Otherwise: Return all active rollouts (up to limit)
+
+    Args:
+        actor_definition_id: Optional connector definition UUID to filter by
+        rollout_id: Optional specific rollout UUID to look up
+        active_only: If True, only return active (non-terminal) rollouts
+        limit: Maximum number of results (default: 100)
+        gsm_client: GCP Secret Manager client. If None, a new client will be instantiated.
+
+    Returns:
+        List of rollout records with version details
+    """
+    if rollout_id is not None:
+        rows = _run_sql_query(
+            SELECT_CONNECTOR_ROLLOUT_BY_ID,
+            parameters={"rollout_id": rollout_id},
+            query_name="SELECT_CONNECTOR_ROLLOUT_BY_ID",
+            gsm_client=gsm_client,
+        )
+        return rows
+
+    # Handle active_only with optional actor_definition_id filter
+    if active_only:
+        if actor_definition_id is not None:
+            # Filter by both active states AND actor_definition_id
+            return _run_sql_query(
+                SELECT_ACTIVE_CONNECTOR_ROLLOUTS_BY_DEFINITION,
+                parameters={
+                    "actor_definition_id": actor_definition_id,
+                    "limit": limit,
+                },
+                query_name="SELECT_ACTIVE_CONNECTOR_ROLLOUTS_BY_DEFINITION",
+                gsm_client=gsm_client,
+            )
+        # Only active filter, no actor_definition_id
+        return _run_sql_query(
+            SELECT_ACTIVE_CONNECTOR_ROLLOUTS,
+            parameters={"limit": limit},
+            query_name="SELECT_ACTIVE_CONNECTOR_ROLLOUTS",
+            gsm_client=gsm_client,
+        )
+
+    # Not active_only, but filter by actor_definition_id (all states)
+    if actor_definition_id is not None:
+        return _run_sql_query(
+            SELECT_CONNECTOR_ROLLOUTS,
+            parameters={
+                "actor_definition_id": actor_definition_id,
+                "limit": limit,
+            },
+            query_name="SELECT_CONNECTOR_ROLLOUTS",
+            gsm_client=gsm_client,
+        )
+
+    # Default: return active rollouts if no filters specified
+    return _run_sql_query(
+        SELECT_ACTIVE_CONNECTOR_ROLLOUTS,
+        parameters={"limit": limit},
+        query_name="SELECT_ACTIVE_CONNECTOR_ROLLOUTS",
+        gsm_client=gsm_client,
+    )

airbyte_ops_mcp/prod_db_access/sql.py

@@ -64,6 +64,19 @@ attempts
 --------
 id, job_id, attempt_number, log_path, output, status, created_at, updated_at,
 ended_at, failure_summary, processing_task_queue, attempt_sync_config
+
+connector_rollout
+-----------------
+id, actor_definition_id, release_candidate_version_id, initial_version_id, state,
+initial_rollout_pct, current_target_rollout_pct, final_target_rollout_pct,
+has_breaking_changes, max_step_wait_time_mins, updated_by, created_at, updated_at,
+completed_at, expires_at, error_msg, failed_reason, rollout_strategy, workflow_run_id,
+paused_reason, filters, tag
+
+Note: state values: 'initialized', 'workflow_started', 'in_progress', 'paused',
+      'finalizing', 'succeeded', 'errored', 'failed_rolled_back', 'canceled'
+      Active states: initialized, workflow_started, in_progress, paused, finalizing, errored
+      Terminal states: succeeded, failed_rolled_back, canceled
 """
 
 from __future__ import annotations
@@ -1010,3 +1023,197 @@ SELECT_CONNECTIONS_BY_SOURCE_CONNECTOR_AND_STREAM_AND_ORG = sqlalchemy.text(
     LIMIT :limit
     """
 )
+
+# =============================================================================
+# Connector Rollout Queries
+# =============================================================================
+
+# List all rollouts for a connector definition, with version details
+SELECT_CONNECTOR_ROLLOUTS = sqlalchemy.text(
+    """
+    SELECT
+         cr.id AS rollout_id,
+         cr.actor_definition_id,
+         cr.state,
+         cr.initial_rollout_pct,
+         cr.current_target_rollout_pct,
+         cr.final_target_rollout_pct,
+         cr.has_breaking_changes,
+         cr.max_step_wait_time_mins,
+         cr.rollout_strategy,
+         cr.workflow_run_id,
+         cr.error_msg,
+         cr.failed_reason,
+         cr.paused_reason,
+         cr.tag,
+         cr.created_at,
+         cr.updated_at,
+         cr.completed_at,
+         cr.expires_at,
+         rc_version.docker_image_tag AS rc_docker_image_tag,
+         rc_version.docker_repository AS rc_docker_repository,
+         initial_version.docker_image_tag AS initial_docker_image_tag,
+         initial_version.docker_repository AS initial_docker_repository
+    FROM connector_rollout cr
+    JOIN actor_definition_version rc_version
+      ON cr.release_candidate_version_id = rc_version.id
+    LEFT JOIN actor_definition_version initial_version
+      ON cr.initial_version_id = initial_version.id
+    WHERE
+         cr.actor_definition_id = :actor_definition_id
+    ORDER BY
+         cr.created_at DESC
+    LIMIT :limit
+    """
+)
+
+# List all active (non-terminal) rollouts across all connectors
+# Active states: initialized, workflow_started, in_progress, paused, finalizing, errored
+SELECT_ACTIVE_CONNECTOR_ROLLOUTS = sqlalchemy.text(
+    """
+    SELECT
+         cr.id AS rollout_id,
+         cr.actor_definition_id,
+         cr.state,
+         cr.initial_rollout_pct,
+         cr.current_target_rollout_pct,
+         cr.final_target_rollout_pct,
+         cr.has_breaking_changes,
+         cr.max_step_wait_time_mins,
+         cr.rollout_strategy,
+         cr.workflow_run_id,
+         cr.error_msg,
+         cr.failed_reason,
+         cr.paused_reason,
+         cr.tag,
+         cr.created_at,
+         cr.updated_at,
+         cr.completed_at,
+         cr.expires_at,
+         rc_version.docker_image_tag AS rc_docker_image_tag,
+         rc_version.docker_repository AS rc_docker_repository,
+         initial_version.docker_image_tag AS initial_docker_image_tag,
+         initial_version.docker_repository AS initial_docker_repository
+    FROM connector_rollout cr
+    JOIN actor_definition_version rc_version
+      ON cr.release_candidate_version_id = rc_version.id
+    LEFT JOIN actor_definition_version initial_version
+      ON cr.initial_version_id = initial_version.id
+    WHERE
+         cr.state IN ('initialized', 'workflow_started', 'in_progress', 'paused', 'finalizing', 'errored')
+    ORDER BY
+         cr.created_at DESC
+    LIMIT :limit
+    """
+)
+
+# List active (non-terminal) rollouts for a specific connector definition
+# Active states: initialized, workflow_started, in_progress, paused, finalizing, errored
+SELECT_ACTIVE_CONNECTOR_ROLLOUTS_BY_DEFINITION = sqlalchemy.text(
+    """
+    SELECT
+         cr.id AS rollout_id,
+         cr.actor_definition_id,
+         cr.state,
+         cr.initial_rollout_pct,
+         cr.current_target_rollout_pct,
+         cr.final_target_rollout_pct,
+         cr.has_breaking_changes,
+         cr.max_step_wait_time_mins,
+         cr.rollout_strategy,
+         cr.workflow_run_id,
+         cr.error_msg,
+         cr.failed_reason,
+         cr.paused_reason,
+         cr.tag,
+         cr.created_at,
+         cr.updated_at,
+         cr.completed_at,
+         cr.expires_at,
+         rc_version.docker_image_tag AS rc_docker_image_tag,
+         rc_version.docker_repository AS rc_docker_repository,
+         initial_version.docker_image_tag AS initial_docker_image_tag,
+         initial_version.docker_repository AS initial_docker_repository
+    FROM connector_rollout cr
+    JOIN actor_definition_version rc_version
+      ON cr.release_candidate_version_id = rc_version.id
+    LEFT JOIN actor_definition_version initial_version
+      ON cr.initial_version_id = initial_version.id
+    WHERE
+         cr.actor_definition_id = :actor_definition_id
+     AND cr.state IN ('initialized', 'workflow_started', 'in_progress', 'paused', 'finalizing', 'errored')
+    ORDER BY
+         cr.created_at DESC
+    LIMIT :limit
+    """
+)
+
+# Get a specific rollout by ID
+SELECT_CONNECTOR_ROLLOUT_BY_ID = sqlalchemy.text(
+    """
+    SELECT
+         cr.id AS rollout_id,
+         cr.actor_definition_id,
+         cr.state,
+         cr.initial_rollout_pct,
+         cr.current_target_rollout_pct,
+         cr.final_target_rollout_pct,
+         cr.has_breaking_changes,
+         cr.max_step_wait_time_mins,
+         cr.rollout_strategy,
+         cr.workflow_run_id,
+         cr.error_msg,
+         cr.failed_reason,
+         cr.paused_reason,
+         cr.filters,
+         cr.tag,
+         cr.created_at,
+         cr.updated_at,
+         cr.completed_at,
+         cr.expires_at,
+         rc_version.docker_image_tag AS rc_docker_image_tag,
+         rc_version.docker_repository AS rc_docker_repository,
+         initial_version.docker_image_tag AS initial_docker_image_tag,
+         initial_version.docker_repository AS initial_docker_repository
+    FROM connector_rollout cr
+    JOIN actor_definition_version rc_version
+      ON cr.release_candidate_version_id = rc_version.id
+    LEFT JOIN actor_definition_version initial_version
+      ON cr.initial_version_id = initial_version.id
+    WHERE
+         cr.id = :rollout_id
+    """
+)
+
+# =============================================================================
+# Connector Rollout Monitoring Queries
+# =============================================================================
+
+# Get actors pinned to a specific rollout (via scoped_configuration.origin = rollout_id)
+# This shows which actors are currently participating in the rollout
+SELECT_ACTORS_PINNED_TO_ROLLOUT = sqlalchemy.text(
+    """
+    SELECT
+         actor.id AS actor_id,
+         actor.name AS actor_name,
+         actor.actor_definition_id,
+         actor.workspace_id,
+         workspace.name AS workspace_name,
+         workspace.organization_id,
+         scoped_configuration.origin_type AS pin_origin_type,
+         scoped_configuration.origin AS pin_origin,
+         scoped_configuration.created_at AS pin_created_at,
+         scoped_configuration.value AS pinned_version_id
+    FROM scoped_configuration
+    JOIN actor
+      ON scoped_configuration.scope_id = actor.id
+    JOIN workspace
+      ON actor.workspace_id = workspace.id
+    WHERE
+         scoped_configuration.key = 'connector_version'
+     AND scoped_configuration.scope_type = 'actor'
+     AND scoped_configuration.origin = :rollout_id
+    ORDER BY
+         scoped_configuration.created_at DESC
+    """
+)