snowflake-cli 3.2.2__py3-none-any.whl → 3.4.1__py3-none-any.whl

snowflake/cli/_plugins/spcs/common.py

@@ -14,7 +14,9 @@
 
 from __future__ import annotations
 
+import json
 import sys
+from datetime import datetime
 from typing import TextIO
 
 from click import ClickException
@@ -23,6 +25,22 @@ from snowflake.cli.api.exceptions import ObjectAlreadyExistsError
 from snowflake.cli.api.project.util import unquote_identifier
 from snowflake.connector.errors import ProgrammingError
 
+EVENT_COLUMN_NAMES = [
+    "TIMESTAMP",
+    "START_TIMESTAMP",
+    "OBSERVED_TIMESTAMP",
+    "TRACE",
+    "RESOURCE",
+    "RESOURCE_ATTRIBUTES",
+    "SCOPE",
+    "SCOPE_ATTRIBUTES",
+    "RECORD_TYPE",
+    "RECORD",
+    "RECORD_ATTRIBUTES",
+    "VALUE",
+    "EXEMPLARS",
+]
+
 if not sys.stdout.closed and sys.stdout.isatty():
     GREEN = "\033[32m"
     BLUE = "\033[34m"
@@ -124,5 +142,116 @@ def new_logs_only(prev_log_records: list[str], new_log_records: list[str]) -> li
     return new_log_records_sorted
 
 
+def build_resource_clause(
+    service_name: str, instance_id: str, container_name: str
+) -> str:
+    resource_filters = []
+    if service_name:
+        resource_filters.append(
+            f"resource_attributes:\"snow.service.name\" = '{service_name}'"
+        )
+    if instance_id:
+        resource_filters.append(
+            f"(resource_attributes:\"snow.service.instance\" = '{instance_id}' "
+            f"OR resource_attributes:\"snow.service.container.instance\" = '{instance_id}')"
+        )
+    if container_name:
+        resource_filters.append(
+            f"resource_attributes:\"snow.service.container.name\" = '{container_name}'"
+        )
+    return " and ".join(resource_filters) if resource_filters else "1=1"
+
+
+def build_time_clauses(
+    since: str | datetime | None, until: str | datetime | None
+) -> tuple[str, str]:
+    since_clause = ""
+    until_clause = ""
+
+    if isinstance(since, datetime):
+        since_clause = f"and timestamp >= '{since}'"
+    elif isinstance(since, str) and since:
+        since_clause = f"and timestamp >= sysdate() - interval '{since}'"
+
+    if isinstance(until, datetime):
+        until_clause = f"and timestamp <= '{until}'"
+    elif isinstance(until, str) and until:
+        until_clause = f"and timestamp <= sysdate() - interval '{until}'"
+
+    return since_clause, until_clause
+
+
+def format_event_row(event_dict: dict) -> dict:
+    try:
+        resource_attributes = json.loads(event_dict.get("RESOURCE_ATTRIBUTES", "{}"))
+        record_attributes = json.loads(event_dict.get("RECORD_ATTRIBUTES", "{}"))
+        record = json.loads(event_dict.get("RECORD", "{}"))
+
+        database_name = resource_attributes.get("snow.database.name", "N/A")
+        schema_name = resource_attributes.get("snow.schema.name", "N/A")
+        service_name = resource_attributes.get("snow.service.name", "N/A")
+        instance_name = resource_attributes.get("snow.service.instance", "N/A")
+        container_name = resource_attributes.get("snow.service.container.name", "N/A")
+        event_name = record_attributes.get("event.name", "Unknown Event")
+        event_value = event_dict.get("VALUE", "Unknown Value")
+        severity = record.get("severity_text", "Unknown Severity")
+
+        return {
+            "TIMESTAMP": event_dict.get("TIMESTAMP", "N/A"),
+            "DATABASE NAME": database_name,
+            "SCHEMA NAME": schema_name,
+            "SERVICE NAME": service_name,
+            "INSTANCE ID": instance_name,
+            "CONTAINER NAME": container_name,
+            "SEVERITY": severity,
+            "EVENT NAME": event_name,
+            "EVENT VALUE": event_value,
+        }
+    except (json.JSONDecodeError, KeyError) as e:
+        raise RecordProcessingError(f"Error processing event row.")
+
+
+def format_metric_row(metric_dict: dict) -> dict:
+    try:
+        resource_attributes = json.loads(metric_dict["RESOURCE_ATTRIBUTES"])
+        record = json.loads(metric_dict["RECORD"])
+
+        database_name = resource_attributes.get("snow.database.name", "N/A")
+        schema_name = resource_attributes.get("snow.schema.name", "N/A")
+        service_name = resource_attributes.get("snow.service.name", "N/A")
+        instance_name = resource_attributes.get(
+            "snow.service.container.instance", "N/A"
+        )
+        container_name = resource_attributes.get("snow.service.container.name", "N/A")
+
+        metric_name = record["metric"].get("name", "Unknown Metric")
+        metric_value = metric_dict.get("VALUE", "Unknown Value")
+
+        return {
+            "TIMESTAMP": metric_dict.get("TIMESTAMP", "N/A"),
+            "DATABASE NAME": database_name,
+            "SCHEMA NAME": schema_name,
+            "SERVICE NAME": service_name,
+            "INSTANCE ID": instance_name,
+            "CONTAINER NAME": container_name,
+            "METRIC NAME": metric_name,
+            "METRIC VALUE": metric_value,
+        }
+    except (json.JSONDecodeError, KeyError) as e:
+        raise RecordProcessingError(f"Error processing metric row.")
+
+
+class RecordProcessingError(ClickException):
+    """Raised when processing an event or metric record fails due to invalid data."""
+
+    pass
+
+
+class SPCSEventTableError(ClickException):
+    """Raised when there is an issue related to the SPCS event table."""
+
+    pass
+
+
 class NoPropertiesProvidedError(ClickException):
     pass

snowflake/cli/_plugins/spcs/services/commands.py

@@ -37,9 +37,12 @@ from snowflake.cli.api.commands.flags import (
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
 from snowflake.cli.api.constants import ObjectType
-from snowflake.cli.api.exceptions import IncompatibleParametersError
+from snowflake.cli.api.exceptions import (
+    IncompatibleParametersError,
+)
 from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.output.types import (
+    CollectionResult,
     CommandResult,
     MessageResult,
     QueryJsonValueResult,
@@ -55,6 +58,38 @@ app = SnowTyperFactory(
     short_help="Manages services.",
 )
 
+# Define common options
+container_name_option = typer.Option(
+    ...,
+    "--container-name",
+    help="Name of the container.",
+    show_default=False,
+)
+
+instance_id_option = typer.Option(
+    ...,
+    "--instance-id",
+    help="ID of the service instance, starting with 0.",
+    show_default=False,
+)
+
+since_option = typer.Option(
+    default="",
+    help="Fetch events that are newer than this time ago, in Snowflake interval syntax.",
+)
+
+until_option = typer.Option(
+    default="",
+    help="Fetch events that are older than this time ago, in Snowflake interval syntax.",
+)
+
+show_all_columns_option = typer.Option(
+    False,
+    "--all",
+    is_flag=True,
+    help="Fetch all columns.",
+)
+
 
 def _service_name_callback(name: FQN) -> FQN:
     if not is_valid_object_name(name.identifier, max_depth=2, allow_quoted=False):
@@ -209,18 +244,8 @@ def status(name: FQN = ServiceNameArgument, **options) -> CommandResult:
 @app.command(requires_connection=True)
 def logs(
     name: FQN = ServiceNameArgument,
-    container_name: str = typer.Option(
-        ...,
-        "--container-name",
-        help="Name of the container.",
-        show_default=False,
-    ),
-    instance_id: str = typer.Option(
-        ...,
-        "--instance-id",
-        help="ID of the service instance, starting with 0.",
-        show_default=False,
-    ),
+    container_name: str = container_name_option,
+    instance_id: str = instance_id_option,
     num_lines: int = typer.Option(
         DEFAULT_NUM_LINES, "--num-lines", help="Number of lines to retrieve."
     ),
@@ -237,12 +262,17 @@ def logs(
         False, "--include-timestamps", help="Include timestamps in logs.", is_flag=True
     ),
     follow: bool = typer.Option(
-        False, "--follow", help="Stream logs in real-time.", is_flag=True
+        False,
+        "--follow",
+        help="Stream logs in real-time.",
+        is_flag=True,
+        hidden=True,
     ),
     follow_interval: int = typer.Option(
         2,
         "--follow-interval",
         help="Set custom polling intervals for log streaming (--follow flag) in seconds.",
+        hidden=True,
     ),
     **options,
 ):
@@ -288,6 +318,93 @@ def logs(
     return StreamResult(cast(Generator[CommandResult, None, None], stream))
 
 
+@app.command(
+    requires_connection=True,
+)
+def events(
+    name: FQN = ServiceNameArgument,
+    container_name: str = container_name_option,
+    instance_id: str = instance_id_option,
+    since: str = since_option,
+    until: str = until_option,
+    first: int = typer.Option(
+        default=None,
+        show_default=False,
+        help="Fetch only the first N events. Cannot be used with --last.",
+    ),
+    last: int = typer.Option(
+        default=None,
+        show_default=False,
+        help="Fetch only the last N events. Cannot be used with --first.",
+    ),
+    show_all_columns: bool = show_all_columns_option,
+    **options,
+):
+    """
+    Retrieve platform events for a service container.
+    """
+
+    if first is not None and last is not None:
+        raise IncompatibleParametersError(["--first", "--last"])
+
+    manager = ServiceManager()
+    events = manager.get_events(
+        service_name=name.identifier,
+        container_name=container_name,
+        instance_id=instance_id,
+        since=since,
+        until=until,
+        first=first,
+        last=last,
+        show_all_columns=show_all_columns,
+    )
+
+    if not events:
+        return MessageResult("No events found.")
+
+    return CollectionResult(events)
+
+
+@app.command(
+    requires_connection=True,
+)
+def metrics(
+    name: FQN = ServiceNameArgument,
+    container_name: str = container_name_option,
+    instance_id: str = instance_id_option,
+    since: str = since_option,
+    until: str = until_option,
+    show_all_columns: bool = show_all_columns_option,
+    **options,
+):
+    """
+    Retrieve platform metrics for a service container.
+    """
+
+    manager = ServiceManager()
+    if since or until:
+        metrics = manager.get_all_metrics(
+            service_name=name.identifier,
+            container_name=container_name,
+            instance_id=instance_id,
+            since=since,
+            until=until,
+            show_all_columns=show_all_columns,
+        )
+    else:
+        metrics = manager.get_latest_metrics(
+            service_name=name.identifier,
+            container_name=container_name,
+            instance_id=instance_id,
+            show_all_columns=show_all_columns,
+        )
+
+    if not metrics:
+        return MessageResult("No metrics found.")
+
+    return CollectionResult(metrics)
+
+
 @app.command(requires_connection=True)
 def upgrade(
     name: FQN = ServiceNameArgument,

snowflake/cli/_plugins/spcs/services/manager.py

@@ -16,14 +16,21 @@ from __future__ import annotations
 
 import json
 import time
+from datetime import datetime
 from pathlib import Path
 from typing import List, Optional
 
 import yaml
 from snowflake.cli._plugins.object.common import Tag
 from snowflake.cli._plugins.spcs.common import (
+    EVENT_COLUMN_NAMES,
     NoPropertiesProvidedError,
+    SPCSEventTableError,
+    build_resource_clause,
+    build_time_clauses,
     filter_log_timestamp,
+    format_event_row,
+    format_metric_row,
     handle_object_already_exists,
     new_logs_only,
     strip_empty_lines,
@@ -31,7 +38,7 @@ from snowflake.cli._plugins.spcs.common import (
 from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB, ObjectType
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
-from snowflake.connector.cursor import SnowflakeCursor
+from snowflake.connector.cursor import DictCursor, SnowflakeCursor
 from snowflake.connector.errors import ProgrammingError
 
 
@@ -199,6 +206,167 @@ class ServiceManager(SqlExecutionMixin):
         except KeyboardInterrupt:
             return
 
+    def get_account_event_table(self):
+        query = "show parameters like 'event_table' in account"
+        results = self.execute_query(query, cursor_class=DictCursor)
+        event_table = next(
+            (r["value"] for r in results if r["key"] == "EVENT_TABLE"), ""
+        )
+        if not event_table:
+            raise SPCSEventTableError("No SPCS event table configured in the account.")
+        return event_table
+
+    def get_events(
+        self,
+        service_name: str,
+        instance_id: str,
+        container_name: str,
+        since: str | datetime | None = None,
+        until: str | datetime | None = None,
+        first: Optional[int] = None,
+        last: Optional[int] = None,
+        show_all_columns: bool = False,
+    ):
+
+        account_event_table = self.get_account_event_table()
+        resource_clause = build_resource_clause(
+            service_name, instance_id, container_name
+        )
+        since_clause, until_clause = build_time_clauses(since, until)
+
+        first_clause = f"limit {first}" if first is not None else ""
+        last_clause = f"limit {last}" if last is not None else ""
+
+        query = f"""\
+                     select *
+                    from (
+                        select *
+                        from {account_event_table}
+                        where (
+                            {resource_clause}
+                            {since_clause}
+                            {until_clause}
+                        )
+                        and record_type = 'LOG'
+                        and scope['name'] = 'snow.spcs.platform'
+                        order by timestamp desc
+                        {last_clause}
+                    )
+                    order by timestamp asc
+                    {first_clause}
+                """
+
+        cursor = self.execute_query(query)
+        raw_events = cursor.fetchall()
+        if not raw_events:
+            return []
+
+        if show_all_columns:
+            return [dict(zip(EVENT_COLUMN_NAMES, event)) for event in raw_events]
+
+        formatted_events = []
+        for raw_event in raw_events:
+            event_dict = dict(zip(EVENT_COLUMN_NAMES, raw_event))
+            formatted = format_event_row(event_dict)
+            formatted_events.append(formatted)
+
+        return formatted_events
+
+    def get_all_metrics(
+        self,
+        service_name: str,
+        instance_id: str,
+        container_name: str,
+        since: str | datetime | None = None,
+        until: str | datetime | None = None,
+        show_all_columns: bool = False,
+    ):
+
+        account_event_table = self.get_account_event_table()
+        resource_clause = build_resource_clause(
+            service_name, instance_id, container_name
+        )
+        since_clause, until_clause = build_time_clauses(since, until)
+
+        query = f"""\
+                    select *
+                    from {account_event_table}
+                    where (
+                        {resource_clause}
+                        {since_clause}
+                        {until_clause}
+                    )
+                    and record_type = 'METRIC'
+                    and scope['name'] = 'snow.spcs.platform'
+                    order by timestamp desc
+                """
+
+        cursor = self.execute_query(query)
+        raw_metrics = cursor.fetchall()
+        if not raw_metrics:
+            return []
+
+        if show_all_columns:
+            return [dict(zip(EVENT_COLUMN_NAMES, metric)) for metric in raw_metrics]
+
+        formatted_metrics = []
+        for raw_metric in raw_metrics:
+            metric_dict = dict(zip(EVENT_COLUMN_NAMES, raw_metric))
+            formatted = format_metric_row(metric_dict)
+            formatted_metrics.append(formatted)
+
+        return formatted_metrics
+
+    def get_latest_metrics(
+        self,
+        service_name: str,
+        instance_id: str,
+        container_name: str,
+        show_all_columns: bool = False,
+    ):
+
+        account_event_table = self.get_account_event_table()
+        resource_clause = build_resource_clause(
+            service_name, instance_id, container_name
+        )
+
+        query = f"""
+            with rankedmetrics as (
+                select
+                    *,
+                    row_number() over (
+                        partition by record['metric']['name']
+                        order by timestamp desc
+                    ) as rank
+                from {account_event_table}
+                where
+                    record_type = 'METRIC'
+                    and scope['name'] = 'snow.spcs.platform'
+                    and {resource_clause}
+                    and timestamp > dateadd('hour', -1, current_timestamp)
+            )
+            select *
+            from rankedmetrics
+            where rank = 1
+            order by timestamp desc;
+        """
+
+        cursor = self.execute_query(query)
+        raw_metrics = cursor.fetchall()
+        if not raw_metrics:
+            return []
+
+        if show_all_columns:
+            return [dict(zip(EVENT_COLUMN_NAMES, metric)) for metric in raw_metrics]
+
+        formatted_metrics = []
+        for raw_metric in raw_metrics:
+            metric_dict = dict(zip(EVENT_COLUMN_NAMES, raw_metric))
+            formatted = format_metric_row(metric_dict)
+            formatted_metrics.append(formatted)
+
+        return formatted_metrics
+
     def upgrade_spec(self, service_name: str, spec_path: Path):
         spec = self._read_yaml(spec_path)
         query = f"alter service {service_name} from specification $$ {spec} $$"

snowflake/cli/_plugins/stage/commands.py

@@ -192,7 +192,8 @@ def stage_diff(
     Diffs a stage with a local folder.
     """
     diff: DiffResult = compute_stage_diff(
-        local_root=Path(folder_name), stage_fqn=stage_name
+        local_root=Path(folder_name),
+        stage_path=StageManager.stage_path_parts_from_str(stage_name),  # noqa: SLF001
     )
     if get_cli_context().output_format == OutputFormat.JSON:
         return ObjectResult(diff.to_dict())