stackport 0.4.0__tar.gz → 0.4.1__tar.gz

{stackport-0.4.0/stackport.egg-info → stackport-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stackport
-Version: 0.4.0
+Version: 0.4.1
 Summary: Universal AWS resource browser for local emulators
 Author: Davi Reis Vieira
 License: MIT

{stackport-0.4.0 → stackport-0.4.1}/backend/main.py

@@ -17,8 +17,8 @@ from botocore.exceptions import (
 )
 
 from backend.config import LOG_LEVEL, STACKPORT_ALLOW_WRITES, STACKPORT_PORT
-from backend.routes import dynamodb, ec2, endpoints, iam, lambda_svc, logs, resources, rds, s3, secretsmanager, sqs, stats, stepfunctions, tags
-from backend.websocket import probe_loop, websocket_endpoint
+from backend.routes import dynamodb, ec2, endpoints, iam, lambda_svc, logs, monitoring, resources, rds, s3, secretsmanager, sns, sqs, stats, stepfunctions, tags
+from backend.websocket import logs_tail_endpoint, probe_loop, websocket_endpoint
 
 
 class HealthcheckFilter(logging.Filter):
@@ -71,6 +71,8 @@ class ReadOnlyMiddleware(BaseHTTPMiddleware):
             return True
         if path.startswith("/api/lambda/functions/") and path.endswith("/invoke"):
             return True
+        if path == "/api/monitoring/metric-data":
+            return True
         # Step Functions start/stop execution are writes, not reads
         return False
 
@@ -127,6 +129,8 @@ app.include_router(stepfunctions.router, prefix="/api/stepfunctions", tags=["ste
 app.include_router(tags.router, prefix="/api", tags=["tags"])
 app.include_router(resources.router, prefix="/api")
 app.include_router(rds.router, prefix="/api/rds", tags=["rds"])
+app.include_router(monitoring.router, prefix="/api/monitoring", tags=["monitoring"])
+app.include_router(sns.router, prefix="/api/sns", tags=["sns"])
 
 
 # WebSocket endpoint for real-time updates
@@ -135,6 +139,12 @@ async def ws(websocket: WebSocket):
     await websocket_endpoint(websocket)
 
 
+# WebSocket endpoint for live log tailing (#85)
+@app.websocket("/ws/logs/tail")
+async def ws_logs_tail(websocket: WebSocket):
+    await logs_tail_endpoint(websocket)
+
+
 # Serve UI static files — mount assets under /assets, SPA fallback for everything else
 ui_dist = os.path.join(os.path.dirname(__file__), "..", "ui", "dist")
 if os.path.isdir(ui_dist):

stackport-0.4.1/backend/routes/monitoring.py

@@ -0,0 +1,131 @@
+"""CloudWatch monitoring routes: dashboards, alarms and metric data (#123)."""
+
+import json
+import logging
+from datetime import datetime, timedelta, timezone
+
+from fastapi import APIRouter, Depends, HTTPException
+
+from backend.aws_client import get_client
+from backend.routes.common import EndpointInfo, get_endpoint_info
+from backend.schemas.monitoring import MetricDataRequest
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+def _iso(value) -> str | None:
+    if value is None:
+        return None
+    if isinstance(value, datetime):
+        return value.isoformat()
+    return str(value)
+
+
+@router.get("/dashboards")
+def list_dashboards(ep: EndpointInfo = Depends(get_endpoint_info)):
+    """List CloudWatch dashboards."""
+    cw = get_client("cloudwatch", **ep.client_kwargs())
+    response = cw.list_dashboards()
+    dashboards = [
+        {
+            "name": entry["DashboardName"],
+            "lastModified": _iso(entry.get("LastModified")),
+            "size": entry.get("Size", 0),
+        }
+        for entry in response.get("DashboardEntries", [])
+    ]
+    return {"dashboards": dashboards}
+
+
+@router.get("/dashboards/{name}")
+def get_dashboard(name: str, ep: EndpointInfo = Depends(get_endpoint_info)):
+    """Get a dashboard with its parsed widget definitions."""
+    cw = get_client("cloudwatch", **ep.client_kwargs())
+    try:
+        response = cw.get_dashboard(DashboardName=name)
+    except Exception as exc:
+        raise HTTPException(status_code=404, detail=f"Dashboard '{name}' not found: {exc}")
+    try:
+        body = json.loads(response.get("DashboardBody") or "{}")
+    except json.JSONDecodeError:
+        body = {}
+    return {"name": name, "body": body}
+
+
+@router.get("/alarms")
+def list_alarms(ep: EndpointInfo = Depends(get_endpoint_info)):
+    """List CloudWatch metric alarms with their state and configuration."""
+    cw = get_client("cloudwatch", **ep.client_kwargs())
+    response = cw.describe_alarms()
+    alarms = [
+        {
+            "name": alarm["AlarmName"],
+            "arn": alarm.get("AlarmArn", ""),
+            "description": alarm.get("AlarmDescription"),
+            "state": alarm.get("StateValue", "INSUFFICIENT_DATA"),
+            "stateReason": alarm.get("StateReason"),
+            "stateUpdated": _iso(alarm.get("StateUpdatedTimestamp")),
+            "namespace": alarm.get("Namespace"),
+            "metricName": alarm.get("MetricName"),
+            "statistic": alarm.get("Statistic"),
+            "period": alarm.get("Period"),
+            "evaluationPeriods": alarm.get("EvaluationPeriods"),
+            "threshold": alarm.get("Threshold"),
+            "comparisonOperator": alarm.get("ComparisonOperator"),
+            "dimensions": [
+                {"name": d.get("Name", ""), "value": d.get("Value", "")} for d in alarm.get("Dimensions", [])
+            ],
+        }
+        for alarm in response.get("MetricAlarms", [])
+    ]
+    return {"alarms": alarms}
+
+
+@router.post("/metric-data")
+def get_metric_data(body: MetricDataRequest, ep: EndpointInfo = Depends(get_endpoint_info)):
+    """Fetch metric time series for dashboard widgets.
+
+    This is a read-only POST (the query set does not fit in a query string);
+    it is allow-listed in the read-only middleware.
+    """
+    if not body.queries:
+        return {"results": []}
+    cw = get_client("cloudwatch", **ep.client_kwargs())
+
+    end = datetime.now(timezone.utc)
+    start = end - timedelta(minutes=max(1, body.start_minutes))
+
+    metric_queries = [
+        {
+            "Id": query.id,
+            "MetricStat": {
+                "Metric": {
+                    "Namespace": query.namespace,
+                    "MetricName": query.metric_name,
+                    "Dimensions": [{"Name": d.name, "Value": d.value} for d in query.dimensions],
+                },
+                "Period": max(1, query.period),
+                "Stat": query.stat,
+            },
+        }
+        for query in body.queries[:100]
+    ]
+
+    try:
+        response = cw.get_metric_data(MetricDataQueries=metric_queries, StartTime=start, EndTime=end)
+    except Exception as exc:
+        logger.debug("get_metric_data failed", exc_info=True)
+        raise HTTPException(status_code=502, detail=f"Failed to fetch metric data: {exc}")
+
+    results = [
+        {
+            "id": series.get("Id", ""),
+            "label": series.get("Label", ""),
+            "timestamps": [_iso(ts) for ts in series.get("Timestamps", [])],
+            "values": series.get("Values", []),
+        }
+        for series in response.get("MetricDataResults", [])
+    ]
+    return {"results": results}

stackport-0.4.1/backend/routes/sns.py

@@ -0,0 +1,210 @@
+"""SNS routes: topics, subscriptions and publishing (#75)."""
+
+import json
+import logging
+
+from fastapi import APIRouter, Depends, HTTPException
+
+from backend.aws_client import get_client
+from backend.routes.common import EndpointInfo, get_endpoint_info
+from backend.schemas.sns import CreateTopicBody, PublishBody, SubscribeBody
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+def _topic_name(arn: str) -> str:
+    return arn.rsplit(":", 1)[-1]
+
+
+def _serialize_topic(arn: str, attributes: dict) -> dict:
+    return {
+        "arn": arn,
+        "name": _topic_name(arn),
+        "displayName": attributes.get("DisplayName") or None,
+        "fifo": attributes.get("FifoTopic") == "true",
+        "contentBasedDeduplication": attributes.get("ContentBasedDeduplication") == "true",
+        "subscriptionsConfirmed": int(attributes.get("SubscriptionsConfirmed") or 0),
+        "subscriptionsPending": int(attributes.get("SubscriptionsPending") or 0),
+        "owner": attributes.get("Owner"),
+        "kmsMasterKeyId": attributes.get("KmsMasterKeyId"),
+    }
+
+
+def _serialize_subscription(sns, sub: dict) -> dict:
+    entry = {
+        "arn": sub.get("SubscriptionArn", ""),
+        "protocol": sub.get("Protocol", ""),
+        "endpoint": sub.get("Endpoint", ""),
+        "owner": sub.get("Owner", ""),
+        "pending": sub.get("SubscriptionArn") == "PendingConfirmation",
+        "filterPolicy": None,
+        "rawMessageDelivery": False,
+    }
+    if not entry["pending"] and entry["arn"]:
+        try:
+            attrs = sns.get_subscription_attributes(SubscriptionArn=entry["arn"]).get("Attributes", {})
+            if attrs.get("FilterPolicy"):
+                try:
+                    entry["filterPolicy"] = json.loads(attrs["FilterPolicy"])
+                except json.JSONDecodeError:
+                    entry["filterPolicy"] = attrs["FilterPolicy"]
+            entry["rawMessageDelivery"] = attrs.get("RawMessageDelivery") == "true"
+        except Exception:
+            logger.debug("Failed to fetch subscription attributes for %s", entry["arn"], exc_info=True)
+    return entry
+
+
+def _list_all_topic_arns(sns) -> list[str]:
+    """list_topics returns at most 100 entries per call; follow NextToken."""
+    arns: list[str] = []
+    token: str | None = None
+    while True:
+        response = sns.list_topics(NextToken=token) if token else sns.list_topics()
+        arns.extend(t["TopicArn"] for t in response.get("Topics", []))
+        token = response.get("NextToken")
+        if not token:
+            return arns
+
+
+def _list_all_subscriptions(sns, topic_arn: str) -> list[dict]:
+    """list_subscriptions_by_topic paginates the same way."""
+    subs: list[dict] = []
+    token: str | None = None
+    while True:
+        if token:
+            response = sns.list_subscriptions_by_topic(TopicArn=topic_arn, NextToken=token)
+        else:
+            response = sns.list_subscriptions_by_topic(TopicArn=topic_arn)
+        subs.extend(response.get("Subscriptions", []))
+        token = response.get("NextToken")
+        if not token:
+            return subs
+
+
+@router.get("/topics")
+def list_topics(ep: EndpointInfo = Depends(get_endpoint_info)):
+    """List SNS topics enriched with their attributes."""
+    sns = get_client("sns", **ep.client_kwargs())
+    topics = []
+    for arn in _list_all_topic_arns(sns):
+        try:
+            attributes = sns.get_topic_attributes(TopicArn=arn).get("Attributes", {})
+        except Exception:
+            logger.debug("Failed to fetch attributes for topic %s", arn, exc_info=True)
+            attributes = {}
+        topics.append(_serialize_topic(arn, attributes))
+    return {"topics": topics}
+
+
+@router.get("/topics/{arn}")
+def get_topic(arn: str, ep: EndpointInfo = Depends(get_endpoint_info)):
+    """Get a topic's attributes and subscriptions."""
+    sns = get_client("sns", **ep.client_kwargs())
+    try:
+        attributes = sns.get_topic_attributes(TopicArn=arn).get("Attributes", {})
+    except Exception as exc:
+        raise HTTPException(status_code=404, detail=f"Topic not found: {exc}")
+
+    subscriptions = [_serialize_subscription(sns, sub) for sub in _list_all_subscriptions(sns, arn)]
+
+    return {
+        **_serialize_topic(arn, attributes),
+        "attributes": attributes,
+        "subscriptions": subscriptions,
+    }
+
+
+@router.post("/topics", status_code=201)
+def create_topic(body: CreateTopicBody, ep: EndpointInfo = Depends(get_endpoint_info)):
+    """Create a Standard or FIFO topic."""
+    sns = get_client("sns", **ep.client_kwargs())
+    name = body.name
+    attributes: dict[str, str] = {}
+    if body.fifo:
+        if not name.endswith(".fifo"):
+            name = f"{name}.fifo"
+        attributes["FifoTopic"] = "true"
+        if body.content_based_deduplication:
+            attributes["ContentBasedDeduplication"] = "true"
+    if body.display_name:
+        attributes["DisplayName"] = body.display_name
+
+    params: dict = {"Name": name}
+    if attributes:
+        params["Attributes"] = attributes
+    try:
+        response = sns.create_topic(**params)
+    except Exception as exc:
+        raise HTTPException(status_code=400, detail=f"Failed to create topic: {exc}")
+    return {"arn": response["TopicArn"], "name": name}
+
+
+@router.delete("/topics/{arn}")
+def delete_topic(arn: str, ep: EndpointInfo = Depends(get_endpoint_info)):
+    """Delete a topic."""
+    sns = get_client("sns", **ep.client_kwargs())
+    try:
+        sns.delete_topic(TopicArn=arn)
+    except Exception as exc:
+        raise HTTPException(status_code=400, detail=f"Failed to delete topic: {exc}")
+    return {"deleted": True, "arn": arn}
+
+
+@router.post("/topics/{arn}/subscriptions", status_code=201)
+def subscribe(arn: str, body: SubscribeBody, ep: EndpointInfo = Depends(get_endpoint_info)):
+    """Subscribe an endpoint to a topic."""
+    sns = get_client("sns", **ep.client_kwargs())
+    attributes: dict[str, str] = {}
+    if body.filter_policy:
+        attributes["FilterPolicy"] = json.dumps(body.filter_policy)
+    if body.raw_message_delivery:
+        attributes["RawMessageDelivery"] = "true"
+    params: dict = {
+        "TopicArn": arn,
+        "Protocol": body.protocol,
+        "Endpoint": body.endpoint,
+        "ReturnSubscriptionArn": True,
+    }
+    if attributes:
+        params["Attributes"] = attributes
+    try:
+        response = sns.subscribe(**params)
+    except Exception as exc:
+        raise HTTPException(status_code=400, detail=f"Failed to subscribe: {exc}")
+    return {"subscriptionArn": response.get("SubscriptionArn", "")}
+
+
+@router.delete("/subscriptions/{arn}")
+def unsubscribe(arn: str, ep: EndpointInfo = Depends(get_endpoint_info)):
+    """Remove a subscription."""
+    sns = get_client("sns", **ep.client_kwargs())
+    try:
+        sns.unsubscribe(SubscriptionArn=arn)
+    except Exception as exc:
+        raise HTTPException(status_code=400, detail=f"Failed to unsubscribe: {exc}")
+    return {"deleted": True, "arn": arn}
+
+
+@router.post("/topics/{arn}/publish")
+def publish(arn: str, body: PublishBody, ep: EndpointInfo = Depends(get_endpoint_info)):
+    """Publish a message to a topic."""
+    sns = get_client("sns", **ep.client_kwargs())
+    params: dict = {"TopicArn": arn, "Message": body.message}
+    if body.subject:
+        params["Subject"] = body.subject
+    if body.message_group_id:
+        params["MessageGroupId"] = body.message_group_id
+    if body.message_deduplication_id:
+        params["MessageDeduplicationId"] = body.message_deduplication_id
+    if body.message_attributes:
+        params["MessageAttributes"] = {
+            key: {"DataType": value.data_type, "StringValue": value.string_value}
+            for key, value in body.message_attributes.items()
+        }
+    try:
+        response = sns.publish(**params)
+    except Exception as exc:
+        raise HTTPException(status_code=400, detail=f"Failed to publish: {exc}")
+    return {"messageId": response.get("MessageId", "")}

stackport-0.4.1/backend/schemas/monitoring.py

@@ -0,0 +1,28 @@
+"""Pydantic schemas for CloudWatch monitoring endpoints."""
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class MetricDimension(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    name: str
+    value: str
+
+
+class MetricDataQuery(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    id: str
+    namespace: str
+    metric_name: str = Field(alias="metricName")
+    dimensions: list[MetricDimension] = []
+    stat: str = "Average"
+    period: int = 60
+
+
+class MetricDataRequest(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    queries: list[MetricDataQuery]
+    start_minutes: int = Field(alias="startMinutes", default=60)

stackport-0.4.1/backend/schemas/sns.py

@@ -0,0 +1,38 @@
+"""Pydantic schemas for SNS endpoints."""
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class CreateTopicBody(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    name: str
+    display_name: str | None = Field(alias="displayName", default=None)
+    fifo: bool = False
+    content_based_deduplication: bool = Field(alias="contentBasedDeduplication", default=False)
+
+
+class SubscribeBody(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    protocol: str
+    endpoint: str
+    filter_policy: dict | None = Field(alias="filterPolicy", default=None)
+    raw_message_delivery: bool = Field(alias="rawMessageDelivery", default=False)
+
+
+class MessageAttributeValue(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    data_type: str = Field(alias="dataType", default="String")
+    string_value: str = Field(alias="stringValue", default="")
+
+
+class PublishBody(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    message: str
+    subject: str | None = None
+    message_group_id: str | None = Field(alias="messageGroupId", default=None)
+    message_deduplication_id: str | None = Field(alias="messageDeduplicationId", default=None)
+    message_attributes: dict[str, MessageAttributeValue] = Field(alias="messageAttributes", default_factory=dict)

{stackport-0.4.0 → stackport-0.4.1}/backend/websocket.py

@@ -8,11 +8,15 @@ import time
 
 from fastapi import WebSocket, WebSocketDisconnect
 
+from backend.aws_client import get_client
 from backend.config import endpoint_store, STACKPORT_SERVICES
+from backend.routes.logs import _epoch_millis_to_iso
 from backend.routes.stats import _probe_service, _start_time
 
 logger = logging.getLogger(__name__)
 
+TAIL_POLL_SECONDS = 1.0
+
 
 class ConnectionManager:
     """Manages active WebSocket connections with per-endpoint subscriptions."""
@@ -146,6 +150,135 @@ async def websocket_endpoint(websocket: WebSocket):
         manager.disconnect(websocket)
 
 
+def _client_kwargs_for(endpoint_name_or_url: str | None) -> dict:
+    """Build get_client kwargs (endpoint URL, region, auth) for an endpoint name or URL."""
+    url = endpoint_store.resolve(endpoint_name_or_url)
+    entry = _find_entry_for_url(url)
+    return {
+        "endpoint_url": url,
+        "region": entry.get("region") if entry else None,
+        "auth_type": entry.get("auth_type", "default") if entry else "default",
+        "auth_profile": entry.get("auth_profile") if entry else None,
+        "auth_access_key_id": entry.get("auth_access_key_id") if entry else None,
+        "auth_secret_access_key": entry.get("auth_secret_access_key") if entry else None,
+    }
+
+
+def _fetch_new_events(
+    group: str,
+    stream: str,
+    since_millis: int,
+    filter_pattern: str,
+    client_kwargs: dict,
+) -> list[dict]:
+    """Fetch log events newer than since_millis; errors degrade to an empty batch."""
+    try:
+        logs = get_client("logs", **client_kwargs)
+        if filter_pattern:
+            params: dict = {
+                "logGroupName": group,
+                "logStreamNames": [stream],
+                "limit": 500,
+                "filterPattern": filter_pattern,
+            }
+            if since_millis > 0:
+                params["startTime"] = since_millis
+            raw = logs.filter_log_events(**params).get("events", [])
+        else:
+            params = {
+                "logGroupName": group,
+                "logStreamName": stream,
+                "limit": 500,
+                "startFromHead": True,
+            }
+            if since_millis > 0:
+                params["startTime"] = since_millis
+            raw = logs.get_log_events(**params).get("events", [])
+    except Exception:
+        logger.debug("Tail fetch failed for %s/%s", group, stream, exc_info=True)
+        return []
+
+    return [
+        {
+            "timestamp": _epoch_millis_to_iso(event["timestamp"]),
+            "timestamp_millis": event["timestamp"],
+            "message": event["message"],
+            "ingestion_time": _epoch_millis_to_iso(event.get("ingestionTime")),
+            "event_id": event.get("eventId", ""),
+        }
+        for event in raw
+    ]
+
+
+async def logs_tail_endpoint(websocket: WebSocket):
+    """Tail a log stream over WebSocket.
+
+    The client opens the socket and sends one configuration message:
+      {"type": "tail", "group": ..., "stream": ..., "endpoint": ...,
+       "filterPattern": ..., "since": <epoch millis of the newest event it has>}
+
+    The server then polls the emulator and pushes {"type": "events", "data": {"events": [...]}}
+    batches until the client sends {"type": "stop"} or disconnects.
+    """
+    await websocket.accept()
+    try:
+        raw = await websocket.receive_text()
+        try:
+            cfg = json.loads(raw)
+        except json.JSONDecodeError:
+            cfg = {}
+        group = cfg.get("group")
+        stream = cfg.get("stream")
+        if cfg.get("type") != "tail" or not group or not stream:
+            await websocket.send_text(json.dumps({"type": "error", "message": "expected a tail message with group and stream"}))
+            await websocket.close()
+            return
+
+        filter_pattern = cfg.get("filterPattern") or ""
+        since = int(cfg.get("since") or time.time() * 1000)
+        client_kwargs = _client_kwargs_for(cfg.get("endpoint"))
+
+        stop = asyncio.Event()
+
+        async def reader():
+            try:
+                while True:
+                    msg = await websocket.receive_text()
+                    try:
+                        if json.loads(msg).get("type") == "stop":
+                            break
+                    except json.JSONDecodeError:
+                        pass
+            except WebSocketDisconnect:
+                pass
+            finally:
+                stop.set()
+
+        reader_task = asyncio.create_task(reader())
+        loop = asyncio.get_event_loop()
+        try:
+            while not stop.is_set():
+                events = await loop.run_in_executor(
+                    None,
+                    functools.partial(_fetch_new_events, group, stream, since, filter_pattern, client_kwargs),
+                )
+                if stop.is_set():
+                    break
+                if events:
+                    since = max(e["timestamp_millis"] for e in events) + 1
+                    await websocket.send_text(json.dumps({"type": "events", "data": {"events": events}}))
+                try:
+                    await asyncio.wait_for(stop.wait(), timeout=TAIL_POLL_SECONDS)
+                except asyncio.TimeoutError:
+                    pass
+        finally:
+            reader_task.cancel()
+    except WebSocketDisconnect:
+        pass
+    except Exception:
+        logger.debug("logs tail connection ended with error", exc_info=True)
+
+
 async def broadcast_endpoints_changed():
     """Broadcast endpoints_changed event to all connected clients."""
     await manager.broadcast_to_all({"type": "endpoints_changed"})

{stackport-0.4.0 → stackport-0.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stackport"
-version = "0.4.0"
+version = "0.4.1"
 description = "Universal AWS resource browser for local emulators"
 readme = "README.md"
 license = {text = "MIT"}

{stackport-0.4.0 → stackport-0.4.1/stackport.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stackport
-Version: 0.4.0
+Version: 0.4.1
 Summary: Universal AWS resource browser for local emulators
 Author: Davi Reis Vieira
 License: MIT