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

honeycomb/resources/environments.py

@@ -20,6 +20,7 @@ class EnvironmentsResource(BaseResource):
 
     This resource requires Management Key authentication and operates
     on a specific team. Environments help organize your data and API keys.
+    The team slug is automatically detected from the management key.
 
     Note:
         The list methods automatically paginate through all results. For teams
@@ -32,9 +33,8 @@ class EnvironmentsResource(BaseResource):
         ...     management_key="hcamk_xxx",
         ...     management_secret="xxx"
         ... ) as client:
-        ...     envs = await client.environments.list_async(team="my-team")
+        ...     envs = await client.environments.list_async()
         ...     env = await client.environments.create_async(
-        ...         team="my-team",
         ...         environment=EnvironmentCreate(
         ...             name="Production",
         ...             description="Production environment",
@@ -48,11 +48,40 @@ class EnvironmentsResource(BaseResource):
         ...     management_secret="xxx",
         ...     sync=True
         ... ) as client:
-        ...     envs = client.environments.list(team="my-team")
+        ...     envs = client.environments.list()
     """
 
     def __init__(self, client: HoneycombClient) -> None:
         super().__init__(client)
+        self._cached_team_slug: str | None = None
+
+    async def _get_team_slug_async(self) -> str:
+        """Get team slug, auto-detecting from auth."""
+        # Use cached value if available
+        if self._cached_team_slug:
+            return self._cached_team_slug
+
+        # Auto-detect from auth endpoint
+        auth_info = await self._client.auth.get_async()
+        if not hasattr(auth_info, "team_slug") or not auth_info.team_slug:
+            raise ValueError("Cannot auto-detect team slug from management key credentials.")
+
+        self._cached_team_slug = auth_info.team_slug
+        return self._cached_team_slug
+
+    def _get_team_slug(self) -> str:
+        """Get team slug (sync), auto-detecting from auth."""
+        # Use cached value if available
+        if self._cached_team_slug:
+            return self._cached_team_slug
+
+        # Auto-detect from auth endpoint
+        auth_info = self._client.auth.get()
+        if not hasattr(auth_info, "team_slug") or not auth_info.team_slug:
+            raise ValueError("Cannot auto-detect team slug from management key credentials.")
+
+        self._cached_team_slug = auth_info.team_slug
+        return self._cached_team_slug
 
     def _build_path(self, team: str, env_id: str | None = None) -> str:
         """Build API path for environments."""
@@ -85,15 +114,12 @@ class EnvironmentsResource(BaseResource):
     # Async methods
     # -------------------------------------------------------------------------
 
-    async def list_async(self, team: str) -> list[Environment]:
-        """List all environments for a team (async).
+    async def list_async(self) -> list[Environment]:
+        """List all environments for the authenticated team (async).
 
         Automatically paginates through all results. For teams with many environments,
         this may result in multiple API requests.
 
-        Args:
-            team: Team slug.
-
         Returns:
             List of Environment objects.
 
@@ -101,6 +127,7 @@ class EnvironmentsResource(BaseResource):
             The default rate limit is 100 requests per minute per operation.
             Contact Honeycomb support for higher limits: https://www.honeycomb.io/support
         """
+        team = await self._get_team_slug_async()
         results: list[Environment] = []
         cursor: str | None = None
         path = self._build_path(team)
@@ -124,29 +151,29 @@ class EnvironmentsResource(BaseResource):
 
         return results
 
-    async def get_async(self, team: str, env_id: str) -> Environment:
+    async def get_async(self, env_id: str) -> Environment:
         """Get a specific environment (async).
 
         Args:
-            team: Team slug.
             env_id: Environment ID.
 
         Returns:
             Environment object.
         """
+        team = await self._get_team_slug_async()
         data = await self._get_async(self._build_path(team, env_id))
         return Environment.from_jsonapi(data)
 
-    async def create_async(self, team: str, environment: EnvironmentCreate) -> Environment:
+    async def create_async(self, environment: EnvironmentCreate) -> Environment:
         """Create a new environment (async).
 
         Args:
-            team: Team slug.
             environment: Environment configuration.
 
         Returns:
             Created Environment object.
         """
+        team = await self._get_team_slug_async()
         data = await self._post_async(
             self._build_path(team),
             json=environment.to_jsonapi(),
@@ -154,19 +181,17 @@ class EnvironmentsResource(BaseResource):
         )
         return Environment.from_jsonapi(data)
 
-    async def update_async(
-        self, team: str, env_id: str, environment: EnvironmentUpdate
-    ) -> Environment:
+    async def update_async(self, env_id: str, environment: EnvironmentUpdate) -> Environment:
         """Update an existing environment (async).
 
         Args:
-            team: Team slug.
             env_id: Environment ID.
             environment: Updated environment configuration.
 
         Returns:
             Updated Environment object.
         """
+        team = await self._get_team_slug_async()
         data = await self._patch_async(
             self._build_path(team, env_id),
             json=environment.to_jsonapi(env_id),
@@ -174,28 +199,25 @@ class EnvironmentsResource(BaseResource):
         )
         return Environment.from_jsonapi(data)
 
-    async def delete_async(self, team: str, env_id: str) -> None:
+    async def delete_async(self, env_id: str) -> None:
         """Delete an environment (async).
 
         Args:
-            team: Team slug.
             env_id: Environment ID.
         """
+        team = await self._get_team_slug_async()
         await self._delete_async(self._build_path(team, env_id))
 
     # -------------------------------------------------------------------------
     # Sync methods
     # -------------------------------------------------------------------------
 
-    def list(self, team: str) -> list[Environment]:
-        """List all environments for a team.
+    def list(self) -> list[Environment]:
+        """List all environments for the authenticated team.
 
         Automatically paginates through all results. For teams with many environments,
         this may result in multiple API requests.
 
-        Args:
-            team: Team slug.
-
         Returns:
             List of Environment objects.
 
@@ -206,6 +228,7 @@ class EnvironmentsResource(BaseResource):
         if not self._client.is_sync:
             raise RuntimeError("Use list_async() for async mode, or pass sync=True to client")
 
+        team = self._get_team_slug()
         results: list[Environment] = []
         cursor: str | None = None
         path = self._build_path(team)
@@ -229,11 +252,10 @@ class EnvironmentsResource(BaseResource):
 
         return results
 
-    def get(self, team: str, env_id: str) -> Environment:
+    def get(self, env_id: str) -> Environment:
         """Get a specific environment.
 
         Args:
-            team: Team slug.
             env_id: Environment ID.
 
         Returns:
@@ -241,14 +263,14 @@ class EnvironmentsResource(BaseResource):
         """
         if not self._client.is_sync:
             raise RuntimeError("Use get_async() for async mode, or pass sync=True to client")
+        team = self._get_team_slug()
         data = self._get_sync(self._build_path(team, env_id))
         return Environment.from_jsonapi(data)
 
-    def create(self, team: str, environment: EnvironmentCreate) -> Environment:
+    def create(self, environment: EnvironmentCreate) -> Environment:
         """Create a new environment.
 
         Args:
-            team: Team slug.
             environment: Environment configuration.
 
         Returns:
@@ -256,6 +278,7 @@ class EnvironmentsResource(BaseResource):
         """
         if not self._client.is_sync:
             raise RuntimeError("Use create_async() for async mode, or pass sync=True to client")
+        team = self._get_team_slug()
         data = self._post_sync(
             self._build_path(team),
             json=environment.to_jsonapi(),
@@ -263,11 +286,10 @@ class EnvironmentsResource(BaseResource):
         )
         return Environment.from_jsonapi(data)
 
-    def update(self, team: str, env_id: str, environment: EnvironmentUpdate) -> Environment:
+    def update(self, env_id: str, environment: EnvironmentUpdate) -> Environment:
         """Update an existing environment.
 
         Args:
-            team: Team slug.
             env_id: Environment ID.
             environment: Updated environment configuration.
 
@@ -276,6 +298,7 @@ class EnvironmentsResource(BaseResource):
         """
         if not self._client.is_sync:
             raise RuntimeError("Use update_async() for async mode, or pass sync=True to client")
+        team = self._get_team_slug()
         data = self._patch_sync(
             self._build_path(team, env_id),
             json=environment.to_jsonapi(env_id),
@@ -283,13 +306,13 @@ class EnvironmentsResource(BaseResource):
         )
         return Environment.from_jsonapi(data)
 
-    def delete(self, team: str, env_id: str) -> None:
+    def delete(self, env_id: str) -> None:
         """Delete an environment.
 
         Args:
-            team: Team slug.
             env_id: Environment ID.
         """
         if not self._client.is_sync:
             raise RuntimeError("Use delete_async() for async mode, or pass sync=True to client")
+        team = self._get_team_slug()
         self._delete_sync(self._build_path(team, env_id))

honeycomb/resources/slos.py

@@ -115,14 +115,16 @@ class SLOsResource(BaseResource):
 
         This method handles the full orchestration of creating an SLO bundle:
         1. Creates derived column if needed (environment-wide or dataset-scoped)
-        2. Creates SLO in each specified dataset
-        3. Creates burn alerts for each SLO (if configured)
+        2. Creates SLO (single-dataset or multi-dataset)
+        3. Creates burn alerts for the SLO (if configured)
 
         Args:
             bundle: SLOBundle from SLOBuilder.build()
 
         Returns:
-            Dictionary mapping dataset slugs to created SLO objects
+            Dictionary mapping dataset slugs to created SLO objects.
+            For single-dataset SLOs: {"dataset": slo}
+            For multi-dataset SLOs: {"dataset1": slo, "dataset2": slo, ...} (same SLO object)
 
         Example:
             >>> bundle = (
@@ -153,39 +155,50 @@ class SLOsResource(BaseResource):
                     bundle.datasets[0], bundle.derived_column
                 )
 
-        # Step 2: Create SLO in each dataset
-        for dataset in bundle.datasets:
+        # Step 2: Create SLO
+        is_multi_dataset = bundle.slo.dataset_slugs is not None
+        if is_multi_dataset:
+            # Multi-dataset SLO: create once via __all__ endpoint
+            slo = await self.create_async("__all__", bundle.slo)
+            # Add to dict for each dataset
+            for dataset in bundle.datasets:
+                created_slos[dataset] = slo
+        else:
+            # Single-dataset SLO: create in the specified dataset
+            dataset = bundle.datasets[0]
             slo = await self.create_async(dataset, bundle.slo)
             created_slos[dataset] = slo
 
-            # Step 3: Create burn alerts for this SLO
-            for alert_def in bundle.burn_alerts:
-                # Process inline recipients with idempotent handling
-                from ._recipient_utils import process_inline_recipients
+        # Step 3: Create burn alerts for the SLO
+        # For multi-dataset SLOs, create burn alerts in the first dataset
+        burn_alert_dataset = bundle.datasets[0]
+        for alert_def in bundle.burn_alerts:
+            # Process inline recipients with idempotent handling
+            from ._recipient_utils import process_inline_recipients
 
-                processed_recipients = await process_inline_recipients(
-                    self._client, alert_def.recipients.copy()
-                )
+            processed_recipients = await process_inline_recipients(
+                self._client, alert_def.recipients.copy()
+            )
 
-                # Convert recipients to BurnAlertRecipient format
-                recipients = [BurnAlertRecipient(**recipient) for recipient in processed_recipients]
-
-                # Convert budget rate percent to per-million if needed
-                budget_rate_threshold = None
-                if alert_def.budget_rate_decrease_percent is not None:
-                    budget_rate_threshold = int(alert_def.budget_rate_decrease_percent * 10000)
-
-                burn_alert = BurnAlertCreate(
-                    alert_type=alert_def.alert_type,
-                    slo_id=slo.id,
-                    description=alert_def.description,
-                    exhaustion_minutes=alert_def.exhaustion_minutes,
-                    budget_rate_window_minutes=alert_def.budget_rate_window_minutes,
-                    budget_rate_decrease_threshold_per_million=budget_rate_threshold,
-                    recipients=recipients if recipients else [],
-                )
+            # Convert recipients to BurnAlertRecipient format
+            recipients = [BurnAlertRecipient(**recipient) for recipient in processed_recipients]
+
+            # Convert budget rate percent to per-million if needed
+            budget_rate_threshold = None
+            if alert_def.budget_rate_decrease_percent is not None:
+                budget_rate_threshold = int(alert_def.budget_rate_decrease_percent * 10000)
+
+            burn_alert = BurnAlertCreate(
+                alert_type=alert_def.alert_type,
+                slo_id=slo.id,
+                description=alert_def.description,
+                exhaustion_minutes=alert_def.exhaustion_minutes,
+                budget_rate_window_minutes=alert_def.budget_rate_window_minutes,
+                budget_rate_decrease_threshold_per_million=budget_rate_threshold,
+                recipients=recipients if recipients else [],
+            )
 
-                await self._client.burn_alerts.create_async(dataset, burn_alert)
+            await self._client.burn_alerts.create_async(burn_alert_dataset, burn_alert)
 
         return created_slos
 
@@ -273,14 +286,16 @@ class SLOsResource(BaseResource):
 
         This method handles the full orchestration of creating an SLO bundle:
         1. Creates derived column if needed (environment-wide or dataset-scoped)
-        2. Creates SLO in each specified dataset
-        3. Creates burn alerts for each SLO (if configured)
+        2. Creates SLO (single-dataset or multi-dataset)
+        3. Creates burn alerts for the SLO (if configured)
 
         Args:
             bundle: SLOBundle from SLOBuilder.build()
 
         Returns:
-            Dictionary mapping dataset slugs to created SLO objects
+            Dictionary mapping dataset slugs to created SLO objects.
+            For single-dataset SLOs: {"dataset": slo}
+            For multi-dataset SLOs: {"dataset1": slo, "dataset2": slo, ...} (same SLO object)
 
         Example:
             >>> bundle = (
@@ -314,40 +329,51 @@ class SLOsResource(BaseResource):
                 # Create in first dataset (single-dataset SLO)
                 self._client.derived_columns.create(bundle.datasets[0], bundle.derived_column)
 
-        # Step 2: Create SLO in each dataset
-        for dataset in bundle.datasets:
+        # Step 2: Create SLO
+        is_multi_dataset = bundle.slo.dataset_slugs is not None
+        if is_multi_dataset:
+            # Multi-dataset SLO: create once via __all__ endpoint
+            slo = self.create("__all__", bundle.slo)
+            # Add to dict for each dataset
+            for dataset in bundle.datasets:
+                created_slos[dataset] = slo
+        else:
+            # Single-dataset SLO: create in the specified dataset
+            dataset = bundle.datasets[0]
             slo = self.create(dataset, bundle.slo)
             created_slos[dataset] = slo
 
-            # Step 3: Create burn alerts for this SLO
-            for alert_def in bundle.burn_alerts:
-                # Process inline recipients with idempotent handling
-                import asyncio
+        # Step 3: Create burn alerts for the SLO
+        # For multi-dataset SLOs, create burn alerts in the first dataset
+        burn_alert_dataset = bundle.datasets[0]
+        for alert_def in bundle.burn_alerts:
+            # Process inline recipients with idempotent handling
+            import asyncio
 
-                from ._recipient_utils import process_inline_recipients
+            from ._recipient_utils import process_inline_recipients
 
-                processed_recipients = asyncio.run(
-                    process_inline_recipients(self._client, alert_def.recipients.copy())
-                )
+            processed_recipients = asyncio.run(
+                process_inline_recipients(self._client, alert_def.recipients.copy())
+            )
 
-                # Convert recipients to BurnAlertRecipient format
-                recipients = [BurnAlertRecipient(**recipient) for recipient in processed_recipients]
-
-                # Convert budget rate percent to per-million if needed
-                budget_rate_threshold = None
-                if alert_def.budget_rate_decrease_percent is not None:
-                    budget_rate_threshold = int(alert_def.budget_rate_decrease_percent * 10000)
-
-                burn_alert = BurnAlertCreate(
-                    alert_type=alert_def.alert_type,
-                    slo_id=slo.id,
-                    description=alert_def.description,
-                    exhaustion_minutes=alert_def.exhaustion_minutes,
-                    budget_rate_window_minutes=alert_def.budget_rate_window_minutes,
-                    budget_rate_decrease_threshold_per_million=budget_rate_threshold,
-                    recipients=recipients if recipients else [],
-                )
+            # Convert recipients to BurnAlertRecipient format
+            recipients = [BurnAlertRecipient(**recipient) for recipient in processed_recipients]
+
+            # Convert budget rate percent to per-million if needed
+            budget_rate_threshold = None
+            if alert_def.budget_rate_decrease_percent is not None:
+                budget_rate_threshold = int(alert_def.budget_rate_decrease_percent * 10000)
+
+            burn_alert = BurnAlertCreate(
+                alert_type=alert_def.alert_type,
+                slo_id=slo.id,
+                description=alert_def.description,
+                exhaustion_minutes=alert_def.exhaustion_minutes,
+                budget_rate_window_minutes=alert_def.budget_rate_window_minutes,
+                budget_rate_decrease_threshold_per_million=budget_rate_threshold,
+                recipients=recipients if recipients else [],
+            )
 
-                self._client.burn_alerts.create(dataset, burn_alert)
+            self._client.burn_alerts.create(burn_alert_dataset, burn_alert)
 
         return created_slos

honeycomb/tools/__main__.py

@@ -3,6 +3,7 @@
 Usage:
     python -m honeycomb.tools generate --output tools.json
     python -m honeycomb.tools generate --resource triggers --output triggers.json
+    python -m honeycomb.tools generate --per-resource --output-dir tools/
     python -m honeycomb.tools validate tools.json
     python -m honeycomb.tools generate --format python --output definitions.py
 """
@@ -14,6 +15,7 @@ from pathlib import Path
 
 from honeycomb.tools.descriptions import validate_description
 from honeycomb.tools.generator import (
+    RESOURCE_MODULES,
     export_tools_json,
     export_tools_python,
     generate_all_tools,
@@ -21,6 +23,9 @@ from honeycomb.tools.generator import (
 )
 from honeycomb.tools.schemas import validate_schema, validate_tool_name
 
+# All available resources
+AVAILABLE_RESOURCES = list(RESOURCE_MODULES.keys())
+
 
 def cmd_generate(args: argparse.Namespace) -> int:
     """Generate tool definitions.
@@ -32,7 +37,28 @@ def cmd_generate(args: argparse.Namespace) -> int:
         Exit code (0 for success, 1 for error)
     """
     try:
-        # Generate tools
+        # Validate arguments
+        if not args.per_resource and not args.output:
+            print("Error: --output is required unless using --per-resource", file=sys.stderr)
+            return 1
+
+        # Handle per-resource generation
+        if args.per_resource:
+            output_dir = Path(args.output_dir)
+            output_dir.mkdir(parents=True, exist_ok=True)
+
+            total_tools = 0
+            for resource in AVAILABLE_RESOURCES:
+                tools = generate_tools_for_resource(resource)
+                output_path = output_dir / f"{resource}.json"
+                export_tools_json(tools, str(output_path))
+                total_tools += len(tools)
+                print(f"  {resource}.json: {len(tools)} tools")
+
+            print(f"Generated {total_tools} tools across {len(AVAILABLE_RESOURCES)} resource files")
+            return 0
+
+        # Generate tools (single file mode)
         if args.resource:
             tools = generate_tools_for_resource(args.resource)
             print(f"Generated {len(tools)} tool definitions for resource '{args.resource}'")
@@ -156,13 +182,12 @@ def main() -> int:
     gen_parser.add_argument(
         "--output",
         "-o",
-        required=True,
-        help="Output file path",
+        help="Output file path (required unless using --per-resource)",
     )
     gen_parser.add_argument(
         "--resource",
         "-r",
-        choices=["triggers", "slos", "burn_alerts"],
+        choices=AVAILABLE_RESOURCES,
         help="Generate tools for specific resource only",
     )
     gen_parser.add_argument(
@@ -172,6 +197,17 @@ def main() -> int:
         default="json",
         help="Output format (default: json)",
     )
+    gen_parser.add_argument(
+        "--per-resource",
+        action="store_true",
+        help="Generate separate JSON files for each resource",
+    )
+    gen_parser.add_argument(
+        "--output-dir",
+        "-d",
+        default="tools",
+        help="Output directory for per-resource files (default: tools)",
+    )
 
     # Validate command
     val_parser = subparsers.add_parser(