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

honeycomb/models/triggers.py

@@ -6,7 +6,7 @@ from datetime import datetime
 from enum import Enum
 from typing import Any
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator
 
 from honeycomb.models.query_builder import (
     CalcOp,
@@ -14,6 +14,7 @@ from honeycomb.models.query_builder import (
     Filter,
     FilterCombination,
 )
+from honeycomb.models.tool_inputs import TagInput
 
 
 class TriggerThresholdOp(str, Enum):
@@ -38,7 +39,10 @@ class TriggerThreshold(BaseModel):
     op: TriggerThresholdOp = Field(description="Comparison operator")
     value: float = Field(description="Threshold value")
     exceeded_limit: int | None = Field(
-        default=None, description="Number of times threshold must be exceeded"
+        default=None,
+        ge=1,
+        le=5,
+        description="Number of times threshold must be exceeded (1-5, default 1)",
     )
 
 
@@ -50,8 +54,6 @@ def _default_calculations() -> list[Calculation | dict[str, Any]]:
 class TriggerQuery(BaseModel):
     """Inline query specification for a trigger.
 
-    Note: time_range must be <= 3600 (1 hour) for triggers.
-
     Accepts both typed models and dicts for flexibility:
         >>> # Using typed models
         >>> TriggerQuery(calculations=[Calculation(op=CalcOp.P99, column="duration_ms")])
@@ -61,9 +63,10 @@ class TriggerQuery(BaseModel):
     """
 
     time_range: int = Field(
-        default=3600,
+        default=900,
+        ge=300,
         le=3600,
-        description="Query time range in seconds (max 3600 for triggers)",
+        description="Query time range in seconds (300-3600, i.e. 5 min to 1 hour)",
     )
     granularity: int | None = Field(default=None, description="Time granularity in seconds")
     calculations: list[Calculation | dict[str, Any]] | None = Field(
@@ -76,6 +79,19 @@ class TriggerQuery(BaseModel):
         default=None, description="How to combine filters (AND/OR)"
     )
 
+    @field_validator("calculations")
+    @classmethod
+    def validate_single_calculation(
+        cls, v: list[Calculation | dict[str, Any]] | None
+    ) -> list[Calculation | dict[str, Any]] | None:
+        """Validate that only one calculation is provided (trigger limitation)."""
+        if v is not None and len(v) > 1:
+            raise ValueError(
+                f"Triggers support only a single calculation, got {len(v)}. "
+                "Use multiple triggers or a saved query if you need multiple calculations."
+            )
+        return v
+
 
 def _normalize_calculation(calc: Calculation | dict[str, Any]) -> dict[str, Any]:
     """Convert a Calculation or dict to API dict format."""
@@ -110,7 +126,8 @@ class TriggerCreate(BaseModel):
         default=900,
         ge=60,
         le=86400,
-        description="Check frequency in seconds (60-86400)",
+        description="Check frequency in seconds (60-86400, must be multiple of 60)",
+        json_schema_extra={"multipleOf": 60},
     )
     query: TriggerQuery | None = Field(default=None, description="Inline query")
     query_id: str | None = Field(default=None, description="Reference to saved query")
@@ -120,7 +137,7 @@ class TriggerCreate(BaseModel):
         description="When to send alerts",
     )
     recipients: list[dict] | None = Field(default=None, description="Notification recipients")
-    tags: list[dict[str, str]] | None = Field(
+    tags: list[TagInput] | None = Field(
         default=None, description="Tags for organizing triggers (max 10)"
     )
     baseline_details: dict[str, Any] | None = Field(
@@ -128,6 +145,14 @@ class TriggerCreate(BaseModel):
         description="Baseline threshold configuration for comparing against historical data",
     )
 
+    @field_validator("frequency")
+    @classmethod
+    def validate_frequency_multiple(cls, v: int) -> int:
+        """Validate that frequency is a multiple of 60."""
+        if v % 60 != 0:
+            raise ValueError(f"Frequency must be a multiple of 60 seconds, got {v}")
+        return v
+
     def model_dump_for_api(self) -> dict[str, Any]:
         """Serialize for API request, handling nested models."""
         data: dict[str, Any] = {
@@ -172,7 +197,7 @@ class TriggerCreate(BaseModel):
             data["recipients"] = self.recipients
 
         if self.tags:
-            data["tags"] = self.tags
+            data["tags"] = [{"key": tag.key, "value": tag.value} for tag in self.tags]
 
         if self.baseline_details:
             data["baseline_details"] = self.baseline_details
@@ -206,3 +231,8 @@ class Trigger(BaseModel):
     updated_at: datetime | None = Field(default=None, description="Last update timestamp")
 
     model_config = {"extra": "allow"}
+
+    @property
+    def dataset(self) -> str:
+        """Alias for dataset_slug for convenience."""
+        return self.dataset_slug

honeycomb/resources/__init__.py

@@ -1,6 +1,7 @@
 """Resource clients for Honeycomb API."""
 
 from .api_keys import ApiKeysResource
+from .auth import AuthResource
 from .base import BaseResource
 from .boards import BoardsResource
 from .burn_alerts import BurnAlertsResource
@@ -30,6 +31,7 @@ __all__ = [
     "BurnAlertsResource",
     "EventsResource",
     "ApiKeysResource",
+    "AuthResource",
     "EnvironmentsResource",
     "ServiceMapDependenciesResource",
 ]

honeycomb/resources/api_keys.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any
 from urllib.parse import parse_qs, urlparse
 
-from ..models.api_keys import ApiKey, ApiKeyCreate
+from ..models.api_keys import ApiKey, ApiKeyCreate, ApiKeyUpdate
 from .base import BaseResource
 
 if TYPE_CHECKING:
@@ -33,9 +33,8 @@ class ApiKeysResource(BaseResource):
         ...     management_key="hcamk_xxx",
         ...     management_secret="xxx"
         ... ) as client:
-        ...     keys = await client.api_keys.list_async(team="my-team")
+        ...     keys = await client.api_keys.list_async()
         ...     key = await client.api_keys.create_async(
-        ...         team="my-team",
         ...         api_key=ApiKeyCreate(
         ...             name="My Ingest Key",
         ...             key_type=ApiKeyType.INGEST,
@@ -49,11 +48,50 @@ class ApiKeysResource(BaseResource):
         ...     management_secret="xxx",
         ...     sync=True
         ... ) as client:
-        ...     keys = client.api_keys.list(team="my-team")
+        ...     keys = client.api_keys.list()
     """
 
     def __init__(self, client: HoneycombClient) -> None:
         super().__init__(client)
+        self._cached_team_slug: str | None = None
+
+    async def _get_team_slug_async(self, team: str | None = None) -> str:
+        """Get team slug, auto-detecting from auth if not provided."""
+        if team:
+            return team
+
+        # 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. Please provide team parameter explicitly."
+            )
+
+        self._cached_team_slug = auth_info.team_slug
+        return self._cached_team_slug
+
+    def _get_team_slug(self, team: str | None = None) -> str:
+        """Get team slug (sync), auto-detecting from auth if not provided."""
+        if team:
+            return team
+
+        # 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. Please provide team parameter explicitly."
+            )
+
+        self._cached_team_slug = auth_info.team_slug
+        return self._cached_team_slug
 
     def _build_path(self, team: str, key_id: str | None = None) -> str:
         """Build API path for API keys."""
@@ -89,14 +127,13 @@ class ApiKeysResource(BaseResource):
     # Async methods
     # -------------------------------------------------------------------------
 
-    async def list_async(self, team: str, key_type: str | None = None) -> list[ApiKey]:
-        """List all API keys for a team (async).
+    async def list_async(self, key_type: str | None = None) -> list[ApiKey]:
+        """List all API keys for the authenticated team (async).
 
         Automatically paginates through all results. For teams with many API keys,
         this may result in multiple API requests.
 
         Args:
-            team: Team slug.
             key_type: Optional filter by key type ('ingest' or 'configuration').
 
         Returns:
@@ -106,6 +143,7 @@ class ApiKeysResource(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[ApiKey] = []
         cursor: str | None = None
         path = self._build_path(team)
@@ -129,29 +167,29 @@ class ApiKeysResource(BaseResource):
 
         return results
 
-    async def get_async(self, team: str, key_id: str) -> ApiKey:
+    async def get_async(self, key_id: str) -> ApiKey:
         """Get a specific API key (async).
 
         Args:
-            team: Team slug.
             key_id: API Key ID.
 
         Returns:
             ApiKey object.
         """
+        team = await self._get_team_slug_async()
         data = await self._get_async(self._build_path(team, key_id))
         return ApiKey.from_jsonapi(data)
 
-    async def create_async(self, team: str, api_key: ApiKeyCreate) -> ApiKey:
+    async def create_async(self, api_key: ApiKeyCreate) -> ApiKey:
         """Create a new API key (async).
 
         Args:
-            team: Team slug.
             api_key: API key configuration.
 
         Returns:
             Created ApiKey object (includes secret, save it immediately!).
         """
+        team = await self._get_team_slug_async()
         data = await self._post_async(
             self._build_path(team),
             json=api_key.to_jsonapi(),
@@ -159,19 +197,18 @@ class ApiKeysResource(BaseResource):
         )
         return ApiKey.from_jsonapi(data)
 
-    async def update_async(self, team: str, key_id: str, api_key: ApiKeyCreate) -> ApiKey:
+    async def update_async(self, key_id: str, api_key: ApiKeyUpdate) -> ApiKey:
         """Update an existing API key (async).
 
         Args:
-            team: Team slug.
             key_id: API Key ID.
             api_key: Updated API key configuration.
 
         Returns:
             Updated ApiKey object.
         """
-        payload = api_key.to_jsonapi()
-        payload["data"]["id"] = key_id  # Include ID for update
+        team = await self._get_team_slug_async()
+        payload = api_key.to_jsonapi(key_id)
         data = await self._patch_async(
             self._build_path(team, key_id),
             json=payload,
@@ -179,27 +216,26 @@ class ApiKeysResource(BaseResource):
         )
         return ApiKey.from_jsonapi(data)
 
-    async def delete_async(self, team: str, key_id: str) -> None:
+    async def delete_async(self, key_id: str) -> None:
         """Delete an API key (async).
 
         Args:
-            team: Team slug.
             key_id: API Key ID.
         """
+        team = await self._get_team_slug_async()
         await self._delete_async(self._build_path(team, key_id))
 
     # -------------------------------------------------------------------------
     # Sync methods
     # -------------------------------------------------------------------------
 
-    def list(self, team: str, key_type: str | None = None) -> list[ApiKey]:
-        """List all API keys for a team.
+    def list(self, key_type: str | None = None) -> list[ApiKey]:
+        """List all API keys for the authenticated team.
 
         Automatically paginates through all results. For teams with many API keys,
         this may result in multiple API requests.
 
         Args:
-            team: Team slug.
             key_type: Optional filter by key type ('ingest' or 'configuration').
 
         Returns:
@@ -212,6 +248,7 @@ class ApiKeysResource(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[ApiKey] = []
         cursor: str | None = None
         path = self._build_path(team)
@@ -235,11 +272,10 @@ class ApiKeysResource(BaseResource):
 
         return results
 
-    def get(self, team: str, key_id: str) -> ApiKey:
+    def get(self, key_id: str) -> ApiKey:
         """Get a specific API key.
 
         Args:
-            team: Team slug.
             key_id: API Key ID.
 
         Returns:
@@ -247,10 +283,11 @@ class ApiKeysResource(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, key_id))
         return ApiKey.from_jsonapi(data)
 
-    def create(self, team: str, api_key: ApiKeyCreate) -> ApiKey:
+    def create(self, api_key: ApiKeyCreate) -> ApiKey:
         """Create a new API key.
 
         Args:
@@ -262,6 +299,7 @@ class ApiKeysResource(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=api_key.to_jsonapi(),
@@ -269,11 +307,10 @@ class ApiKeysResource(BaseResource):
         )
         return ApiKey.from_jsonapi(data)
 
-    def update(self, team: str, key_id: str, api_key: ApiKeyCreate) -> ApiKey:
+    def update(self, key_id: str, api_key: ApiKeyUpdate) -> ApiKey:
         """Update an existing API key.
 
         Args:
-            team: Team slug.
             key_id: API Key ID.
             api_key: Updated API key configuration.
 
@@ -282,8 +319,8 @@ class ApiKeysResource(BaseResource):
         """
         if not self._client.is_sync:
             raise RuntimeError("Use update_async() for async mode, or pass sync=True to client")
-        payload = api_key.to_jsonapi()
-        payload["data"]["id"] = key_id
+        team = self._get_team_slug()
+        payload = api_key.to_jsonapi(key_id)
         data = self._patch_sync(
             self._build_path(team, key_id),
             json=payload,
@@ -291,13 +328,13 @@ class ApiKeysResource(BaseResource):
         )
         return ApiKey.from_jsonapi(data)
 
-    def delete(self, team: str, key_id: str) -> None:
+    def delete(self, key_id: str) -> None:
         """Delete an API key.
 
         Args:
-            team: Team slug.
             key_id: API Key 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, key_id))

honeycomb/resources/auth.py

@@ -0,0 +1,97 @@
+"""Auth resource for retrieving API key metadata."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from honeycomb.models.auth import AuthInfo, AuthInfoV2
+from honeycomb.resources.base import BaseResource
+
+if TYPE_CHECKING:
+    from honeycomb.client import HoneycombClient
+
+
+class AuthResource(BaseResource):
+    """Access authentication metadata for the current API key.
+
+    Example:
+        >>> # Auto-detects endpoint based on credentials
+        >>> auth_info = await client.auth.get_async()
+        >>> print(f"Team: {auth_info.team_name}")
+
+        >>> # Force v2 endpoint (requires management key)
+        >>> auth_info = await client.auth.get_async(use_v2=True)
+        >>> print(f"Scopes: {auth_info.scopes}")
+    """
+
+    def __init__(self, client: HoneycombClient) -> None:
+        super().__init__(client)
+
+    def _is_management_auth(self) -> bool:
+        """Check if client is using management key authentication."""
+        from honeycomb.auth import ManagementKeyAuth
+
+        return isinstance(self._client._auth, ManagementKeyAuth)
+
+    def _require_management_auth(self) -> None:
+        """Raise error if not using management key authentication."""
+        if not self._is_management_auth():
+            raise ValueError(
+                "v2 auth endpoint requires management key authentication. "
+                "Initialize client with management_key and management_secret."
+            )
+
+    async def get_async(self, *, use_v2: bool | None = None) -> AuthInfo | AuthInfoV2:
+        """Get metadata about the current API key.
+
+        Args:
+            use_v2: Force v2 endpoint. If None, auto-detects based on credentials.
+                   If True with API key credentials, raises ValueError.
+
+        Returns:
+            AuthInfo for v1 (API key) or AuthInfoV2 for v2 (management key).
+        """
+        if use_v2 is None:
+            use_v2 = self._is_management_auth()
+
+        if use_v2:
+            self._require_management_auth()
+            data = await self._get_async("/2/auth")
+            return AuthInfoV2.from_jsonapi(data)
+
+        data = await self._get_async("/1/auth")
+        return AuthInfo(
+            id=data.get("id", ""),
+            type=data.get("type", ""),
+            team_name=data.get("team", {}).get("name", ""),
+            team_slug=data.get("team", {}).get("slug", ""),
+            environment_name=data.get("environment", {}).get("name", ""),
+            environment_slug=data.get("environment", {}).get("slug", ""),
+            api_key_access=data.get("api_key_access", {}),
+            time_to_live=data.get("time_to_live"),
+        )
+
+    def get(self, *, use_v2: bool | None = None) -> AuthInfo | AuthInfoV2:
+        """Get metadata about the current API key (sync version)."""
+        if not self._client.is_sync:
+            raise RuntimeError("Use get_async() for async mode, or pass sync=True to client")
+
+        if use_v2 is None:
+            use_v2 = self._is_management_auth()
+
+        if use_v2:
+            self._require_management_auth()
+            data = self._get_sync("/2/auth")
+            return AuthInfoV2.from_jsonapi(data)
+
+        data = self._get_sync("/1/auth")
+        return AuthInfo(
+            id=data.get("id", ""),
+            type=data.get("type", ""),
+            team_name=data.get("team", {}).get("name", ""),
+            team_slug=data.get("team", {}).get("slug", ""),
+            environment_name=data.get("environment", {}).get("name", ""),
+            environment_slug=data.get("environment", {}).get("slug", ""),
+            api_key_access=data.get("api_key_access", {}),
+            time_to_live=data.get("time_to_live"),
+        )