honeycomb-api 0.1.0__py3-none-any.whl → 0.5.3__py3-none-any.whl

honeycomb/cli/environments.py

@@ -0,0 +1,240 @@
+"""Environments management commands (v2 team-scoped)."""
+
+import typer
+from rich.console import Console
+
+from honeycomb.cli.config import get_api_key_from_config, get_client
+from honeycomb.cli.formatters import DEFAULT_OUTPUT_FORMAT, OutputFormat, output_result
+from honeycomb.models.environments import EnvironmentColor, EnvironmentCreate
+
+app = typer.Typer(help="Manage environments (requires management key)")
+console = Console()
+
+
+@app.command("list")
+def list_environments(
+    profile: str | None = typer.Option(None, "--profile", "-p", help="Config profile to use"),
+    management_key: str | None = typer.Option(
+        None, "--management-key", envvar="HONEYCOMB_MANAGEMENT_KEY"
+    ),
+    management_secret: str | None = typer.Option(
+        None, "--management-secret", envvar="HONEYCOMB_MANAGEMENT_SECRET"
+    ),
+    output: OutputFormat = typer.Option(DEFAULT_OUTPUT_FORMAT, "--output", "-o"),
+) -> None:
+    """List all environments for your authenticated team.
+
+    Examples:
+        hny environments list
+    """
+    try:
+        client = get_client(
+            profile=profile,
+            management_key=management_key,
+            management_secret=management_secret,
+        )
+
+        envs = client.environments.list()
+        output_result(envs, output)
+
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("get")
+def get_environment(
+    env_id: str = typer.Argument(..., help="Environment ID"),
+    with_datasets: bool = typer.Option(
+        False, "--with-datasets", help="Also list datasets in this environment"
+    ),
+    profile: str | None = typer.Option(None, "--profile", "-p", help="Config profile to use"),
+    management_key: str | None = typer.Option(
+        None, "--management-key", envvar="HONEYCOMB_MANAGEMENT_KEY"
+    ),
+    management_secret: str | None = typer.Option(
+        None, "--management-secret", envvar="HONEYCOMB_MANAGEMENT_SECRET"
+    ),
+    output: OutputFormat = typer.Option(DEFAULT_OUTPUT_FORMAT, "--output", "-o"),
+) -> None:
+    """Get a specific environment by ID for your authenticated team.
+
+    Examples:
+        hny environments get env-123
+        hny environments get env-123 --with-datasets
+    """
+    try:
+        client = get_client(
+            profile=profile,
+            management_key=management_key,
+            management_secret=management_secret,
+        )
+
+        env = client.environments.get(env_id=env_id)
+        output_result(env, output)
+
+        # Optionally list datasets
+        if with_datasets:
+            api_key = get_api_key_from_config(profile)
+            if not api_key:
+                console.print(
+                    "\n[yellow]Cannot list datasets:[/yellow] No HONEYCOMB_API_KEY found. "
+                    "Set HONEYCOMB_API_KEY environment variable or add api_key to your profile.",
+                    style="bold",
+                )
+                return
+
+            # Create temporary client with API key to verify environment match
+            from honeycomb import HoneycombClient
+
+            with HoneycombClient(api_key=api_key, sync=True) as api_key_client:
+                # Verify the API key is for this environment (force v1 for environment_slug)
+                from honeycomb.models.auth import AuthInfo
+
+                auth_info = api_key_client.auth.get(use_v2=False)
+                assert isinstance(auth_info, AuthInfo)  # use_v2=False always returns AuthInfo
+                if auth_info.environment_slug != env.slug:
+                    console.print(
+                        f"\n[yellow]Cannot list datasets:[/yellow] HONEYCOMB_API_KEY is for environment "
+                        f"'{auth_info.environment_slug}' but you requested '{env.slug}'. "
+                        "Provide an API key for the correct environment.",
+                        style="bold",
+                    )
+                    return
+
+                # Environment matches - list datasets
+                console.print("\n[cyan]Datasets in this environment:[/cyan]")
+                datasets = api_key_client.datasets.list()
+                output_result(datasets, output)
+
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("create")
+def create_environment(
+    name: str = typer.Option(..., "--name", help="Environment name"),
+    description: str | None = typer.Option(None, "--description", "-d", help="Description"),
+    color: EnvironmentColor | None = typer.Option(None, "--color", help="Display color"),
+    profile: str | None = typer.Option(None, "--profile", "-p", help="Config profile to use"),
+    management_key: str | None = typer.Option(
+        None, "--management-key", envvar="HONEYCOMB_MANAGEMENT_KEY"
+    ),
+    management_secret: str | None = typer.Option(
+        None, "--management-secret", envvar="HONEYCOMB_MANAGEMENT_SECRET"
+    ),
+    output: OutputFormat = typer.Option(DEFAULT_OUTPUT_FORMAT, "--output", "-o"),
+) -> None:
+    """Create a new environment for your authenticated team.
+
+    Examples:
+        hny environments create --name "Production"
+        hny environments create --name "Staging" --color blue --description "Staging env"
+    """
+    try:
+        client = get_client(
+            profile=profile,
+            management_key=management_key,
+            management_secret=management_secret,
+        )
+
+        environment = EnvironmentCreate(
+            name=name,
+            description=description,
+            color=color,
+        )
+
+        created = client.environments.create(environment=environment)
+        output_result(created, output)
+
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("update")
+def update_environment(
+    env_id: str = typer.Argument(..., help="Environment ID"),
+    description: str | None = typer.Option(None, "--description", "-d", help="New description"),
+    color: EnvironmentColor | None = typer.Option(None, "--color", help="New color"),
+    delete_protected: bool | None = typer.Option(
+        None, "--delete-protected/--no-delete-protected", help="Enable/disable delete protection"
+    ),
+    profile: str | None = typer.Option(None, "--profile", "-p", help="Config profile to use"),
+    management_key: str | None = typer.Option(
+        None, "--management-key", envvar="HONEYCOMB_MANAGEMENT_KEY"
+    ),
+    management_secret: str | None = typer.Option(
+        None, "--management-secret", envvar="HONEYCOMB_MANAGEMENT_SECRET"
+    ),
+    output: OutputFormat = typer.Option(DEFAULT_OUTPUT_FORMAT, "--output", "-o"),
+) -> None:
+    """Update an environment for your authenticated team.
+
+    Examples:
+        hny environments update env-123 --description "Updated"
+        hny environments update env-123 --no-delete-protected
+    """
+    try:
+        from honeycomb.models.environments import EnvironmentUpdate
+
+        client = get_client(
+            profile=profile,
+            management_key=management_key,
+            management_secret=management_secret,
+        )
+
+        update = EnvironmentUpdate(
+            description=description,
+            color=color,
+            delete_protected=delete_protected,
+        )
+
+        updated = client.environments.update(env_id=env_id, environment=update)
+        output_result(updated, output)
+
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("delete")
+def delete_environment(
+    env_id: str = typer.Argument(..., help="Environment ID"),
+    profile: str | None = typer.Option(None, "--profile", "-p", help="Config profile to use"),
+    management_key: str | None = typer.Option(
+        None, "--management-key", envvar="HONEYCOMB_MANAGEMENT_KEY"
+    ),
+    management_secret: str | None = typer.Option(
+        None, "--management-secret", envvar="HONEYCOMB_MANAGEMENT_SECRET"
+    ),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+) -> None:
+    """Delete an environment for your authenticated team.
+
+    Note: Environment must not be delete-protected.
+
+    Examples:
+        hny environments delete env-123
+        hny environments delete env-123 --yes
+    """
+    try:
+        if not yes:
+            confirm = typer.confirm(f"Delete environment {env_id}?")
+            if not confirm:
+                console.print("Cancelled")
+                raise typer.Exit(0)
+
+        client = get_client(
+            profile=profile,
+            management_key=management_key,
+            management_secret=management_secret,
+        )
+
+        client.environments.delete(env_id=env_id)
+        console.print(f"[green]Deleted environment:[/green] {env_id}")
+
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)

honeycomb/cli/formatters.py

@@ -0,0 +1,242 @@
+"""
+Output formatters for CLI commands.
+
+Supports table, JSON, and YAML output formats.
+"""
+
+import json
+from enum import Enum
+from typing import Any
+
+import yaml
+from pydantic import BaseModel
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+
+class OutputFormat(str, Enum):
+    """Output format for CLI commands."""
+
+    table = "table"
+    json = "json"
+    yaml = "yaml"
+
+
+# Default output format for CLI commands
+DEFAULT_OUTPUT_FORMAT = OutputFormat.table
+
+
+def output_result(
+    data: Any,
+    format: OutputFormat,
+    columns: list[str] | None = None,
+    quiet: bool = False,
+    column_titles: dict[str, str] | None = None,
+) -> None:
+    """
+    Output data in the specified format.
+
+    Args:
+        data: Data to output (Pydantic model, list of models, or dict)
+        format: Output format (table, json, yaml)
+        columns: Column names for table output (only used if format is table)
+        quiet: If True, only output IDs (one per line)
+        column_titles: Optional mapping of column names to display titles
+    """
+    # Handle quiet mode
+    if quiet:
+        if isinstance(data, list):
+            for item in data:
+                if isinstance(item, BaseModel):
+                    console.print(item.id if hasattr(item, "id") else str(item))
+                elif isinstance(item, dict):
+                    console.print(item.get("id", str(item)))
+        elif isinstance(data, BaseModel):
+            console.print(data.id if hasattr(data, "id") else str(data))
+        elif isinstance(data, dict):
+            console.print(data.get("id", str(data)))
+        return
+
+    # Special handling for QueryResult objects in table mode (duck typing check)
+    if (
+        format == OutputFormat.table
+        and isinstance(data, BaseModel)
+        and hasattr(data, "data")
+        and data.data is not None
+        and hasattr(data.data, "rows")
+    ):
+        _output_query_result(data)
+        return
+
+    # Convert Pydantic models to dicts for easier handling
+    data_dict: Any
+    if isinstance(data, BaseModel):
+        data_dict = data.model_dump(mode="json")
+    elif isinstance(data, list) and data and isinstance(data[0], BaseModel):
+        data_dict = [item.model_dump(mode="json") for item in data]
+    else:
+        data_dict = data
+
+    # Output in requested format
+    if format == OutputFormat.json:
+        console.print(json.dumps(data_dict, indent=2, default=str))
+    elif format == OutputFormat.yaml:
+        console.print(yaml.dump(data_dict, default_flow_style=False, sort_keys=False))
+    elif format == OutputFormat.table:
+        if isinstance(data_dict, list):
+            _output_table(data_dict, columns, column_titles)
+        else:
+            # Single item - output as key-value pairs
+            _output_single_item(data_dict)
+
+
+def _output_table(
+    data: list[dict[str, Any]],
+    columns: list[str] | None = None,
+    column_titles: dict[str, str] | None = None,
+) -> None:
+    """Output a list of items as a table."""
+    if not data:
+        console.print("[yellow]No results found[/yellow]")
+        return
+
+    # Determine columns to display
+    if columns is None:
+        # Use all keys from first item, excluding timestamp fields
+        all_columns = list(data[0].keys())
+        # Filter out timestamp fields (can be added back with explicit columns parameter)
+        columns = [
+            col for col in all_columns if col not in ("created_at", "updated_at", "timestamps")
+        ]
+
+    table = Table()
+    for col in columns:
+        # Use custom title if provided, otherwise auto-generate from column name
+        title = column_titles.get(col) if column_titles else None
+        if title is None:
+            title = col.replace("_", " ").title()
+        # ID columns should never truncate
+        if col == "id" or col.endswith("_id"):
+            table.add_column(title, style="cyan", no_wrap=True)
+        else:
+            table.add_column(title, style="cyan")
+
+    for item in data:
+        row = []
+        for col in columns:
+            value = item.get(col)
+            # Display "-" for missing or None values
+            row.append(str(value) if value is not None else "-")
+        table.add_row(*row)
+
+    console.print(table)
+
+
+def _output_single_item(data: dict[str, Any]) -> None:
+    """Output a single item as key-value pairs in a table."""
+    from rich import box
+
+    table = Table(show_header=True, box=box.ROUNDED, padding=(0, 1))
+    table.add_column("Field", style="cyan bold", no_wrap=True)
+    table.add_column("Value", style="white")
+
+    for key, value in data.items():
+        # Format complex values with nested tables/panels for clarity
+        value_display: Any
+        if isinstance(value, dict):
+            if value:
+                # Create a mini-table for dict values
+                nested_table = Table(show_header=False, box=box.SIMPLE, padding=(0, 1))
+                nested_table.add_column("Key", style="cyan")
+                nested_table.add_column("Value", style="white")
+                for k, v in value.items():
+                    nested_table.add_row(str(k), str(v))
+                value_display = nested_table
+            else:
+                value_display = "{}"
+        elif isinstance(value, list):
+            if value:
+                # Special handling for scopes - split on ':' to show resource:permission
+                if key == "scopes" and value and isinstance(value[0], str) and ":" in value[0]:
+                    nested_table = Table(show_header=False, box=box.SIMPLE, padding=(0, 1))
+                    nested_table.add_column("Resource", style="cyan")
+                    nested_table.add_column("Permission", style="white")
+                    for item in value:
+                        parts = str(item).split(":", 1)
+                        if len(parts) == 2:
+                            nested_table.add_row(parts[0], parts[1])
+                        else:
+                            nested_table.add_row(str(item), "")
+                    value_display = nested_table
+                else:
+                    # Regular list - single column
+                    nested_table = Table(show_header=False, box=box.SIMPLE, padding=(0, 1))
+                    nested_table.add_column("Value", style="white")
+                    for item in value:
+                        nested_table.add_row(str(item))
+                    value_display = nested_table
+            else:
+                value_display = "[]"
+        else:
+            value_display = str(value)
+
+        table.add_row(key, value_display)
+
+    console.print(table)
+
+
+def _output_query_result(result: Any) -> None:
+    """Output a QueryResult object with proper formatting.
+
+    Displays query results as a table with breakdown columns and calculation results.
+    Shows query URL and result count.
+    """
+    # Check if data is available
+    if not result.data or not hasattr(result.data, "rows"):
+        console.print("[yellow]No data available (query may still be processing)[/yellow]")
+        return
+
+    rows = result.data.rows
+
+    if not rows:
+        console.print("[yellow]Query returned no results[/yellow]")
+        # Still show the query URL
+        if result.links and "query_url" in result.links:
+            console.print(f"\n[dim]View in UI: {result.links['query_url']}[/dim]")
+        return
+
+    # Create table with all columns from first row
+    table = Table(title=f"Query Results ({len(rows)} rows)")
+
+    # Get all column names from first row
+    columns = list(rows[0].keys())
+
+    for col in columns:
+        # Style calculation columns differently
+        if col.isupper() or col.startswith("P"):  # COUNT, AVG, P99, etc.
+            table.add_column(col, style="green bold", justify="right")
+        else:
+            table.add_column(col, style="cyan")
+
+    # Add rows
+    for row in rows:
+        formatted_row = []
+        for col in columns:
+            value = row.get(col, "-")
+            # Format numbers nicely
+            if isinstance(value, (int, float)):
+                if isinstance(value, float):
+                    formatted_row.append(f"{value:.2f}")
+                else:
+                    formatted_row.append(str(value))
+            else:
+                formatted_row.append(str(value))
+        table.add_row(*formatted_row)
+
+    console.print(table)
+
+    # Show query metadata
+    if result.links and "query_url" in result.links:
+        console.print(f"\n[dim]View in UI: {result.links['query_url']}[/dim]")

honeycomb/cli/markers.py

@@ -0,0 +1,151 @@
+"""
+Marker management commands.
+"""
+
+import json
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from honeycomb.cli.config import get_client
+from honeycomb.cli.formatters import DEFAULT_OUTPUT_FORMAT, OutputFormat, output_result
+from honeycomb.models.markers import MarkerCreate
+
+app = typer.Typer(help="Manage markers (event annotations)")
+console = Console()
+
+
+@app.command("list")
+def list_markers(
+    dataset: str = typer.Option(..., "--dataset", "-d", help="Dataset slug"),
+    profile: str | None = typer.Option(None, "--profile", "-p", help="Config profile"),
+    api_key: str | None = typer.Option(None, "--api-key", envvar="HONEYCOMB_API_KEY"),
+    output: OutputFormat = typer.Option(DEFAULT_OUTPUT_FORMAT, "--output", "-o"),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Only output marker IDs"),
+) -> None:
+    """List all markers in a dataset."""
+    try:
+        client = get_client(profile=profile, api_key=api_key)
+        markers = client.markers.list(dataset=dataset)
+        output_result(
+            markers,
+            output,
+            columns=["id", "message", "type", "start_time", "created_at"],
+            quiet=quiet,
+        )
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("get")
+def get_marker(
+    marker_id: str = typer.Argument(..., help="Marker ID"),
+    dataset: str = typer.Option(..., "--dataset", "-d", help="Dataset slug"),
+    profile: str | None = typer.Option(None, "--profile", "-p", help="Config profile"),
+    api_key: str | None = typer.Option(None, "--api-key", envvar="HONEYCOMB_API_KEY"),
+    output: OutputFormat = typer.Option(DEFAULT_OUTPUT_FORMAT, "--output", "-o"),
+) -> None:
+    """Get a specific marker by ID."""
+    try:
+        client = get_client(profile=profile, api_key=api_key)
+        # Markers API doesn't have a direct get, so list and filter
+        markers = client.markers.list(dataset=dataset)
+        marker = next((m for m in markers if m.id == marker_id), None)
+
+        if marker is None:
+            console.print(f"[red]Error:[/red] Marker {marker_id} not found", style="bold")
+            raise typer.Exit(1)
+
+        output_result(marker, output)
+    except typer.Exit:
+        raise
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("create")
+def create_marker(
+    dataset: str = typer.Option(..., "--dataset", "-d", help="Dataset slug"),
+    from_file: Path = typer.Option(..., "--from-file", "-f", help="JSON file with marker config"),
+    profile: str | None = typer.Option(None, "--profile", "-p", help="Config profile"),
+    api_key: str | None = typer.Option(None, "--api-key", envvar="HONEYCOMB_API_KEY"),
+    output: OutputFormat = typer.Option(DEFAULT_OUTPUT_FORMAT, "--output", "-o"),
+) -> None:
+    """Create a marker from a JSON file."""
+    try:
+        client = get_client(profile=profile, api_key=api_key)
+
+        # Load and parse JSON file
+        data = json.loads(from_file.read_text())
+
+        # Strip fields that shouldn't be in create request
+        data.pop("id", None)
+        data.pop("created_at", None)
+        data.pop("updated_at", None)
+
+        marker_create = MarkerCreate.model_validate(data)
+        marker = client.markers.create(dataset=dataset, marker=marker_create)
+
+        console.print(f"[green]Created marker with ID: {marker.id}[/green]")
+        output_result(marker, output)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("update")
+def update_marker(
+    marker_id: str = typer.Argument(..., help="Marker ID"),
+    dataset: str = typer.Option(..., "--dataset", "-d", help="Dataset slug"),
+    from_file: Path = typer.Option(..., "--from-file", "-f", help="JSON file with marker config"),
+    profile: str | None = typer.Option(None, "--profile", "-p", help="Config profile"),
+    api_key: str | None = typer.Option(None, "--api-key", envvar="HONEYCOMB_API_KEY"),
+    output: OutputFormat = typer.Option(DEFAULT_OUTPUT_FORMAT, "--output", "-o"),
+) -> None:
+    """Update an existing marker."""
+    try:
+        client = get_client(profile=profile, api_key=api_key)
+
+        # Load and parse JSON file
+        data = json.loads(from_file.read_text())
+
+        # Strip fields that shouldn't be in update request
+        data.pop("id", None)
+        data.pop("created_at", None)
+        data.pop("updated_at", None)
+
+        marker_update = MarkerCreate.model_validate(data)
+        marker = client.markers.update(dataset=dataset, marker_id=marker_id, marker=marker_update)
+
+        console.print(f"[green]Updated marker {marker.id}[/green]")
+        output_result(marker, output)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("delete")
+def delete_marker(
+    marker_id: str = typer.Argument(..., help="Marker ID"),
+    dataset: str = typer.Option(..., "--dataset", "-d", help="Dataset slug"),
+    profile: str | None = typer.Option(None, "--profile", "-p", help="Config profile"),
+    api_key: str | None = typer.Option(None, "--api-key", envvar="HONEYCOMB_API_KEY"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+) -> None:
+    """Delete a marker."""
+    try:
+        if not yes:
+            confirm = typer.confirm(f"Delete marker {marker_id} from dataset {dataset}?")
+            if not confirm:
+                console.print("[yellow]Cancelled[/yellow]")
+                raise typer.Exit(0)
+
+        client = get_client(profile=profile, api_key=api_key)
+        client.markers.delete(dataset=dataset, marker_id=marker_id)
+        console.print(f"[green]Deleted marker {marker_id}[/green]")
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)