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

honeycomb/cli/slos.py

@@ -0,0 +1,338 @@
+"""
+SLO 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.slos import SLOCreate
+
+app = typer.Typer(help="Manage SLOs (Service Level Objectives)")
+console = Console()
+
+
+@app.command("list")
+def list_slos(
+    dataset: str = typer.Option(
+        "__all__", "--dataset", "-d", help="Dataset slug (default: __all__ for environment-wide)"
+    ),
+    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 SLO IDs"),
+) -> None:
+    """List all SLOs (environment-wide by default, or in a specific dataset)."""
+    try:
+        client = get_client(profile=profile, api_key=api_key)
+        slos = client.slos.list(dataset=dataset)
+
+        # Add computed columns for table display
+        slos_with_computed = []
+        for slo in slos:
+            slo_dict = slo.model_dump(mode="json")
+            # Show "environment-wide" or comma-separated dataset slugs
+            if slo.dataset_slugs and len(slo.dataset_slugs) > 0:
+                if slo.dataset_slugs == ["__all__"]:
+                    slo_dict["datasets"] = "environment-wide"
+                else:
+                    slo_dict["datasets"] = ", ".join(slo.dataset_slugs)
+            else:
+                slo_dict["datasets"] = "environment-wide"
+            # Add target_percentage for user-friendly display
+            slo_dict["target_percentage"] = slo.target_percentage
+            slos_with_computed.append(slo_dict)
+
+        output_result(
+            slos_with_computed if output == OutputFormat.table else slos,
+            output,
+            columns=[
+                "id",
+                "name",
+                "datasets",
+                "target_percentage",
+                "time_period_days",
+                "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_slo(
+    slo_id: str = typer.Argument(..., help="SLO ID"),
+    dataset: str | None = typer.Option(
+        None, "--dataset", "-d", help="Dataset slug (auto-detected if not provided)"
+    ),
+    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 SLO."""
+    try:
+        client = get_client(profile=profile, api_key=api_key)
+
+        # If dataset not provided, find it by listing all SLOs
+        if dataset is None:
+            all_slos = client.slos.list(dataset="__all__")
+            matching = [s for s in all_slos if s.id == slo_id]
+            if not matching:
+                console.print(f"[red]Error:[/red] SLO {slo_id} not found", style="bold")
+                raise typer.Exit(1)
+
+            slo = matching[0]
+            # Check if SLO spans multiple datasets
+            if slo.dataset_slugs and len(slo.dataset_slugs) > 1:
+                datasets_str = ", ".join(slo.dataset_slugs)
+                console.print(
+                    f"[yellow]Note:[/yellow] SLO {slo_id} spans multiple datasets: {datasets_str}"
+                )
+                console.print(
+                    "[yellow]Fetching from first dataset. Use --dataset to specify a different one.[/yellow]"
+                )
+
+            found_dataset = slo.dataset
+            if not found_dataset:
+                console.print(f"[red]Error:[/red] SLO {slo_id} has no dataset", style="bold")
+                raise typer.Exit(1)
+            dataset = found_dataset
+            console.print(f"[dim]Found SLO in dataset: {dataset}[/dim]")
+            # We already have the SLO from the list, just output it
+            output_result(slo, output)
+        else:
+            # Dataset provided, fetch directly
+            slo = client.slos.get(dataset=dataset, slo_id=slo_id)
+            output_result(slo, output)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("create")
+def create_slo(
+    dataset: str = typer.Option(..., "--dataset", "-d", help="Dataset slug"),
+    from_file: Path = typer.Option(..., "--from-file", "-f", help="JSON file with SLO 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 an SLO 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)
+
+        slo_create = SLOCreate.model_validate(data)
+        slo = client.slos.create(dataset=dataset, slo=slo_create)
+
+        console.print(f"[green]Created SLO '{slo.name}' with ID: {slo.id}[/green]")
+        output_result(slo, output)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("update")
+def update_slo(
+    slo_id: str = typer.Argument(..., help="SLO ID"),
+    dataset: str = typer.Option(..., "--dataset", "-d", help="Dataset slug"),
+    from_file: Path = typer.Option(..., "--from-file", "-f", help="JSON file with SLO 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 SLO."""
+    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)
+
+        slo_update = SLOCreate.model_validate(data)
+        slo = client.slos.update(dataset=dataset, slo_id=slo_id, slo=slo_update)
+
+        console.print(f"[green]Updated SLO '{slo.name}'[/green]")
+        output_result(slo, output)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("delete")
+def delete_slo(
+    slo_id: str = typer.Argument(..., help="SLO ID"),
+    dataset: str | None = typer.Option(
+        None, "--dataset", "-d", help="Dataset slug (auto-detected if not provided)"
+    ),
+    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 an SLO."""
+    try:
+        client = get_client(profile=profile, api_key=api_key)
+
+        # If dataset not provided, find it by listing all SLOs
+        if dataset is None:
+            all_slos = client.slos.list(dataset="__all__")
+            matching = [s for s in all_slos if s.id == slo_id]
+            if not matching:
+                console.print(f"[red]Error:[/red] SLO {slo_id} not found", style="bold")
+                raise typer.Exit(1)
+
+            slo = matching[0]
+            # Check if SLO spans multiple datasets - must use __all__ to delete
+            if slo.dataset_slugs and len(slo.dataset_slugs) > 1:
+                datasets_str = ", ".join(slo.dataset_slugs)
+                console.print(f"[dim]SLO {slo_id} spans multiple datasets: {datasets_str}[/dim]")
+                dataset = "__all__"
+                console.print("[dim]Using dataset=__all__ for deletion[/dim]")
+            else:
+                found_dataset = slo.dataset
+                if not found_dataset:
+                    console.print(f"[red]Error:[/red] SLO {slo_id} has no dataset", style="bold")
+                    raise typer.Exit(1)
+                dataset = found_dataset
+                console.print(f"[dim]Found SLO in dataset: {dataset}[/dim]")
+        else:
+            # If dataset is explicitly provided for a multi-dataset SLO and it's not __all__, error
+            all_slos = client.slos.list(dataset="__all__")
+            matching = [s for s in all_slos if s.id == slo_id]
+            if matching:
+                slo = matching[0]
+                if slo.dataset_slugs and len(slo.dataset_slugs) > 1 and dataset != "__all__":
+                    datasets_str = ", ".join(slo.dataset_slugs)
+                    console.print(
+                        f"[red]Error:[/red] SLO {slo_id} spans multiple datasets: {datasets_str}",
+                        style="bold",
+                    )
+                    console.print(
+                        "[yellow]Multi-dataset SLOs can only be deleted with --dataset __all__[/yellow]"
+                    )
+                    raise typer.Exit(1)
+
+        if not yes:
+            confirm = typer.confirm(f"Delete SLO {slo_id} from dataset {dataset}?")
+            if not confirm:
+                console.print("[yellow]Cancelled[/yellow]")
+                raise typer.Exit(0)
+
+        client.slos.delete(dataset=dataset, slo_id=slo_id)
+        console.print(f"[green]Deleted SLO {slo_id}[/green]")
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("export")
+def export_slo(
+    slo_id: str = typer.Argument(..., help="SLO ID"),
+    dataset: str | None = typer.Option(
+        None, "--dataset", "-d", help="Dataset slug (auto-detected if not provided)"
+    ),
+    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_file: Path | None = typer.Option(
+        None, "--output-file", "-o", help="Output file (default: stdout)"
+    ),
+) -> None:
+    """
+    Export an SLO as JSON.
+
+    Output is suitable for importing to another environment via the 'create' command.
+    """
+    try:
+        client = get_client(profile=profile, api_key=api_key)
+
+        # If dataset not provided, find it by listing all SLOs
+        if dataset is None:
+            all_slos = client.slos.list(dataset="__all__")
+            matching = [s for s in all_slos if s.id == slo_id]
+            if not matching:
+                console.print(f"[red]Error:[/red] SLO {slo_id} not found", style="bold")
+                raise typer.Exit(1)
+
+            slo = matching[0]
+            # Check if SLO spans multiple datasets
+            if slo.dataset_slugs and len(slo.dataset_slugs) > 1:
+                datasets_str = ", ".join(slo.dataset_slugs)
+                console.print(
+                    f"[yellow]Warning:[/yellow] SLO {slo_id} spans multiple datasets: {datasets_str}"
+                )
+                console.print(
+                    "[yellow]Exporting from first dataset. Use --dataset to specify a different one.[/yellow]"
+                )
+
+            found_dataset = slo.dataset
+            if not found_dataset:
+                console.print(f"[red]Error:[/red] SLO {slo_id} has no dataset", style="bold")
+                raise typer.Exit(1)
+            dataset = found_dataset
+            console.print(f"[dim]Exporting SLO from dataset: {dataset}[/dim]")
+        else:
+            # Dataset provided, fetch directly
+            slo = client.slos.get(dataset=dataset, slo_id=slo_id)
+
+        # Export without IDs/timestamps for portability
+        data = slo.model_dump(exclude={"id", "created_at", "updated_at"}, mode="json")
+        json_str = json.dumps(data, indent=2, default=str)
+
+        if output_file:
+            output_file.write_text(json_str)
+            console.print(f"[green]Exported SLO to {output_file}[/green]")
+        else:
+            console.print(json_str)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("export-all")
+def export_all_slos(
+    dataset: str = typer.Option(..., "--dataset", "-d", help="Dataset slug"),
+    output_dir: Path = typer.Option(..., "--output-dir", help="Output directory"),
+    profile: str | None = typer.Option(None, "--profile", "-p", help="Config profile"),
+    api_key: str | None = typer.Option(None, "--api-key", envvar="HONEYCOMB_API_KEY"),
+) -> None:
+    """Export all SLOs from a dataset to individual JSON files."""
+    try:
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        client = get_client(profile=profile, api_key=api_key)
+        slos = client.slos.list(dataset=dataset)
+
+        for slo in slos:
+            # Export without IDs/timestamps
+            data = slo.model_dump(exclude={"id", "created_at", "updated_at"}, mode="json")
+
+            # Sanitize filename (replace special chars with dash)
+            filename = f"{slo.name}.json".replace("/", "-").replace(" ", "-").lower()
+            file_path = output_dir / filename
+
+            with open(file_path, "w") as f:
+                json.dump(data, f, indent=2, default=str)
+
+            console.print(f"[green]Exported '{slo.name}' to {file_path}[/green]")
+
+        console.print(f"\n[bold green]Exported {len(slos)} SLOs to {output_dir}[/bold green]")
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)

honeycomb/cli/triggers.py

@@ -0,0 +1,271 @@
+"""
+Trigger 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.triggers import TriggerCreate
+
+app = typer.Typer(help="Manage triggers (alerts)")
+console = Console()
+
+
+@app.command("list")
+def list_triggers(
+    dataset: str = typer.Option(
+        "__all__", "--dataset", "-d", help="Dataset slug (default: __all__ for environment-wide)"
+    ),
+    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 trigger IDs"),
+) -> None:
+    """List all triggers (environment-wide by default, or in a specific dataset)."""
+    try:
+        client = get_client(profile=profile, api_key=api_key)
+        triggers = client.triggers.list(dataset=dataset)
+
+        # Add computed dataset column for table display
+        triggers_with_dataset = []
+        for trigger in triggers:
+            trigger_dict = trigger.model_dump(mode="json")
+            # Show "environment-wide" for environment-wide triggers, otherwise show dataset slug
+            if trigger.dataset_slug == "__all__":
+                trigger_dict["dataset"] = "environment-wide"
+            else:
+                trigger_dict["dataset"] = trigger.dataset_slug
+            triggers_with_dataset.append(trigger_dict)
+
+        output_result(
+            triggers_with_dataset if output == OutputFormat.table else triggers,
+            output,
+            columns=["id", "name", "dataset", "disabled", "frequency", "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_trigger(
+    trigger_id: str = typer.Argument(..., help="Trigger ID"),
+    dataset: str | None = typer.Option(
+        None, "--dataset", "-d", help="Dataset slug (auto-detected if not provided)"
+    ),
+    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 trigger."""
+    try:
+        client = get_client(profile=profile, api_key=api_key)
+
+        # If dataset not provided, find it by listing all triggers
+        if dataset is None:
+            all_triggers = client.triggers.list(dataset="__all__")
+            matching = [t for t in all_triggers if t.id == trigger_id]
+            if not matching:
+                console.print(f"[red]Error:[/red] Trigger {trigger_id} not found", style="bold")
+                raise typer.Exit(1)
+            trigger = matching[0]
+            dataset = trigger.dataset
+            console.print(f"[dim]Found trigger in dataset: {dataset}[/dim]")
+            # We already have the trigger from the list, just output it
+            output_result(trigger, output)
+        else:
+            # Dataset provided, fetch directly
+            trigger = client.triggers.get(dataset=dataset, trigger_id=trigger_id)
+            output_result(trigger, output)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("create")
+def create_trigger(
+    dataset: str = typer.Option(..., "--dataset", "-d", help="Dataset slug"),
+    from_file: Path = typer.Option(..., "--from-file", "-f", help="JSON file with trigger 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 trigger 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)
+
+        trigger_create = TriggerCreate.model_validate(data)
+        trigger = client.triggers.create(dataset=dataset, trigger=trigger_create)
+
+        console.print(f"[green]Created trigger '{trigger.name}' with ID: {trigger.id}[/green]")
+        output_result(trigger, output)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("update")
+def update_trigger(
+    trigger_id: str = typer.Argument(..., help="Trigger ID"),
+    dataset: str = typer.Option(..., "--dataset", "-d", help="Dataset slug"),
+    from_file: Path = typer.Option(..., "--from-file", "-f", help="JSON file with trigger 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 trigger."""
+    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)
+
+        trigger_update = TriggerCreate.model_validate(data)
+        trigger = client.triggers.update(
+            dataset=dataset, trigger_id=trigger_id, trigger=trigger_update
+        )
+
+        console.print(f"[green]Updated trigger '{trigger.name}'[/green]")
+        output_result(trigger, output)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("delete")
+def delete_trigger(
+    trigger_id: str = typer.Argument(..., help="Trigger ID"),
+    dataset: str | None = typer.Option(
+        None, "--dataset", "-d", help="Dataset slug (auto-detected if not provided)"
+    ),
+    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 trigger."""
+    try:
+        client = get_client(profile=profile, api_key=api_key)
+
+        # If dataset not provided, find it by listing all triggers
+        if dataset is None:
+            all_triggers = client.triggers.list(dataset="__all__")
+            matching = [t for t in all_triggers if t.id == trigger_id]
+            if not matching:
+                console.print(f"[red]Error:[/red] Trigger {trigger_id} not found", style="bold")
+                raise typer.Exit(1)
+            dataset = matching[0].dataset
+            console.print(f"[dim]Found trigger in dataset: {dataset}[/dim]")
+
+        if not yes:
+            confirm = typer.confirm(f"Delete trigger {trigger_id} from dataset {dataset}?")
+            if not confirm:
+                console.print("[yellow]Cancelled[/yellow]")
+                raise typer.Exit(0)
+
+        client.triggers.delete(dataset=dataset, trigger_id=trigger_id)
+        console.print(f"[green]Deleted trigger {trigger_id}[/green]")
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("export")
+def export_trigger(
+    trigger_id: str = typer.Argument(..., help="Trigger ID"),
+    dataset: str | None = typer.Option(
+        None, "--dataset", "-d", help="Dataset slug (auto-detected if not provided)"
+    ),
+    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_file: Path | None = typer.Option(
+        None, "--output-file", "-o", help="Output file (default: stdout)"
+    ),
+) -> None:
+    """
+    Export a trigger as JSON.
+
+    Output is suitable for importing to another environment via the 'create' command.
+    """
+    try:
+        client = get_client(profile=profile, api_key=api_key)
+
+        # If dataset not provided, find it by listing all triggers
+        if dataset is None:
+            all_triggers = client.triggers.list(dataset="__all__")
+            matching = [t for t in all_triggers if t.id == trigger_id]
+            if not matching:
+                console.print(f"[red]Error:[/red] Trigger {trigger_id} not found", style="bold")
+                raise typer.Exit(1)
+            trigger = matching[0]
+            dataset = trigger.dataset
+            console.print(f"[dim]Found trigger in dataset: {dataset}[/dim]")
+        else:
+            # Dataset provided, fetch directly
+            trigger = client.triggers.get(dataset=dataset, trigger_id=trigger_id)
+
+        # Export without IDs/timestamps for portability
+        data = trigger.model_dump(exclude={"id", "created_at", "updated_at"}, mode="json")
+        json_str = json.dumps(data, indent=2, default=str)
+
+        if output_file:
+            output_file.write_text(json_str)
+            console.print(f"[green]Exported trigger to {output_file}[/green]")
+        else:
+            console.print(json_str)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)
+
+
+@app.command("export-all")
+def export_all_triggers(
+    dataset: str = typer.Option(..., "--dataset", "-d", help="Dataset slug"),
+    output_dir: Path = typer.Option(..., "--output-dir", help="Output directory"),
+    profile: str | None = typer.Option(None, "--profile", "-p", help="Config profile"),
+    api_key: str | None = typer.Option(None, "--api-key", envvar="HONEYCOMB_API_KEY"),
+) -> None:
+    """Export all triggers from a dataset to individual JSON files."""
+    try:
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        client = get_client(profile=profile, api_key=api_key)
+        triggers = client.triggers.list(dataset=dataset)
+
+        for trigger in triggers:
+            # Export without IDs/timestamps
+            data = trigger.model_dump(exclude={"id", "created_at", "updated_at"}, mode="json")
+
+            # Sanitize filename (replace special chars with dash)
+            filename = f"{trigger.name}.json".replace("/", "-").replace(" ", "-").lower()
+            file_path = output_dir / filename
+
+            with open(file_path, "w") as f:
+                json.dump(data, f, indent=2, default=str)
+
+            console.print(f"[green]Exported '{trigger.name}' to {file_path}[/green]")
+
+        console.print(
+            f"\n[bold green]Exported {len(triggers)} triggers to {output_dir}[/bold green]"
+        )
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}", style="bold")
+        raise typer.Exit(1)

honeycomb/client.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import asyncio
 from contextlib import suppress
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from datetime import datetime
 from email.utils import parsedate_to_datetime
 from typing import TYPE_CHECKING, Any
@@ -26,6 +26,7 @@ from .exceptions import (
 
 if TYPE_CHECKING:
     from .resources.api_keys import ApiKeysResource
+    from .resources.auth import AuthResource
     from .resources.boards import BoardsResource
     from .resources.burn_alerts import BurnAlertsResource
     from .resources.columns import ColumnsResource
@@ -64,12 +65,7 @@ class RetryConfig:
     base_delay: float = 1.0
     max_delay: float = 30.0
     exponential_base: float = 2.0
-    retry_statuses: set[int] = None  # type: ignore
-
-    def __post_init__(self) -> None:
-        """Initialize default retry statuses if not provided."""
-        if self.retry_statuses is None:
-            self.retry_statuses = {429, 500, 502, 503, 504}
+    retry_statuses: set[int] = field(default_factory=lambda: {429, 500, 502, 503, 504})
 
 
 @dataclass
@@ -154,6 +150,7 @@ class HoneycombClient:
         self._burn_alerts: BurnAlertsResource | None = None
         self._events: EventsResource | None = None
         self._api_keys: ApiKeysResource | None = None
+        self._auth_resource: AuthResource | None = None
         self._environments: EnvironmentsResource | None = None
         self._service_map_dependencies: ServiceMapDependenciesResource | None = None
 
@@ -287,6 +284,15 @@ class HoneycombClient:
             self._api_keys = ApiKeysResource(self)
         return self._api_keys
 
+    @property
+    def auth(self) -> AuthResource:
+        """Access the Auth API."""
+        if self._auth_resource is None:
+            from .resources.auth import AuthResource
+
+            self._auth_resource = AuthResource(self)
+        return self._auth_resource
+
     @property
     def environments(self) -> EnvironmentsResource:
         """Access the Environments API (v2 team-scoped)."""