How to Monitor Aspecto with Vigilmon (HTTP + TCP + Alerts)

Aspecto is an OpenTelemetry-native observability platform that provides distributed tracing, service dependency visualization, and API flow monitoring for microservice architectures. Its backend ingests spans from every instrumented service, stores trace data, and drives the UI that engineers use to debug latency spikes, trace cross-service failures, and validate API contracts in development and production. When Aspecto's backend becomes unavailable, trace ingestion halts silently across the entire fleet — engineers keep working but lose visibility into system behavior at exactly the moment they may need it most. Vigilmon fills the monitoring gap that Aspecto cannot fill for itself: external HTTP and TCP checks from outside your infrastructure that continue operating even when the tracing platform has failed. You can add your first monitor for free, no credit card required.

Why Aspecto needs external monitoring

Collector crash drops spans from all instrumented services simultaneously. Aspecto's collector is the single ingress point for all OpenTelemetry spans. When it crashes or becomes unreachable, every SDK exporter starts buffering spans in memory. Once those in-memory buffers fill, spans are silently dropped — no alert fires inside Aspecto because there are no incoming spans to trigger threshold rules. Engineers discover the gap hours later when they notice suspicious blank time windows in their trace dashboards.
Storage backend saturation causes trace queries to time out. Aspecto stores high-volume trace data in a columnar or time-series storage backend. When storage becomes saturated — full disk, connection pool exhaustion, or IOPS limits — trace queries begin timing out. The API may still accept new spans, so the ingestion monitor appears green while the query path is completely broken. A separate HTTP monitor on the query endpoint detects this split failure state.
Reverse proxy misconfiguration exposes the backend on the wrong path. Teams that self-host Aspecto often place it behind nginx or Traefik. Path prefix or header rewriting errors can cause some endpoints to return 404 while others respond correctly. The Aspecto UI shows an error state but engineers assume it is a browser caching issue or a momentary glitch rather than a proxy misconfiguration. An external monitor with specific URL path checks immediately identifies which endpoints have broken routing.
Certificate rotation causes all SDK exporters to fail simultaneously. OpenTelemetry SDK exporters use strict TLS validation by default. When the Aspecto ingestion endpoint's certificate is rotated without updating the exporter trust stores, every service in the fleet immediately stops sending traces and the error is reported locally in each service's logs — not centrally in Aspecto. An SSL monitor that fires days before expiry gives the team time to coordinate the rotation before span ingestion is interrupted.
Database failover window creates a partial outage with misleading behavior. Aspecto's primary database failover during a maintenance window or hardware failure can take 30 to 90 seconds. During that window, the API returns sporadic 503 or 500 errors and some trace writes are lost. Application-level health checks that only test the process liveness miss this window entirely. An external Vigilmon monitor polled every 60 seconds reliably captures the down event and records the exact outage duration.

What you'll need

A running Aspecto instance with its API and collector accessible over HTTPS
The public hostname for your Aspecto deployment, for example https://aspecto.example.com
A free Vigilmon account — monitors start running in under a minute with no credit card required

Step 1: Expose Aspecto's health endpoint

Verify your Aspecto installation is reachable and identify the health and ingestion endpoints before configuring Vigilmon.

# Check the Aspecto API health endpoint
curl -I https://aspecto.example.com/api/health

# Sample output:
# HTTP/2 200
# content-type: application/json
# x-aspecto-version: 2.1.4

# Verify the response body
curl -s https://aspecto.example.com/api/health | jq .

# Sample output:
# {
#   "status": "ok",
#   "version": "2.1.4",
#   "uptime": 432000
# }

# Test the OTLP HTTP ingestion endpoint
curl -s -o /dev/null -w "%{http_code}" \
  -X POST https://aspecto.example.com/v1/traces \
  -H "Content-Type: application/json" \
  -d '{"resourceSpans":[]}'
# Expected: 200

# Check the UI is being served
curl -I https://aspecto.example.com/
# Expected: HTTP/2 200

If Aspecto is deployed on Kubernetes, verify the pods and service are healthy:

# Check pod status
kubectl get pods -n aspecto

# Sample output:
# NAME                              READY   STATUS    RESTARTS   AGE
# aspecto-api-7d8c9f6b4-xr3mp      1/1     Running   0          5d
# aspecto-collector-5f7b8d9c2-kp4n 1/1     Running   0          5d
# aspecto-storage-0                1/1     Running   0          5d

# Check the service endpoints
kubectl get svc -n aspecto

# Sample output:
# NAME                TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)
# aspecto-api         LoadBalancer   10.96.12.34    203.0.113.55    443:30443/TCP
# aspecto-collector   ClusterIP      10.96.45.67    <none>          4318/TCP

# Fetch health via the external IP
curl -I https://203.0.113.55/api/health

Step 2: Set up HTTP monitoring in Vigilmon

Add an HTTP monitor for the Aspecto health endpoint:

Log in to vigilmon.online and click Add Monitor.
Set Monitor type to HTTP.
Enter the URL: https://aspecto.example.com/api/health
Set Check interval to 60 seconds and Expected status code to 200.
Add a Keyword match for "status":"ok" to confirm the response body is healthy, not a cached error.
Click Save Monitor — Vigilmon will run the first check within a minute.

Add a monitor for the Aspecto OTLP ingestion endpoint

The ingestion endpoint is the most operationally critical path — its failure halts trace collection across all services:

Click Add Monitor again.
Set Monitor type to HTTP.
Enter the URL: https://aspecto.example.com/v1/traces
Set Method to POST, Expected status code to 200, and Timeout to 15 seconds.
Set a Request body of {"resourceSpans":[]} and Content-Type header to application/json.
Click Save Monitor.

Why external monitoring catches what internal checks miss

Aspecto's own alerting depends on trace data flowing through the platform. When the platform itself fails, no data flows, and no alerts fire — leaving your team in the dark at exactly the moment external monitoring matters most. Vigilmon checks your Aspecto endpoints from external network nodes on a fixed schedule. It detects TLS handshake failures, DNS resolution errors, load balancer degradation, and HTTP 5xx responses that are completely invisible to in-cluster health probes. Because Vigilmon does not share any infrastructure with Aspecto, it provides a fully independent uptime signal that survives a complete Aspecto outage.

Step 3: Monitor Aspecto's TCP port

A TCP monitor verifies network-level connectivity to the Aspecto server before TLS negotiation or HTTP parsing. This catches cases where a firewall rule change, a port binding error, or a load balancer failure prevents connections from being established at all.

In Vigilmon, click Add Monitor.
Set Monitor type to TCP.
Enter Host: aspecto.example.com and Port: 443.
Set Check interval to 60 seconds.
Click Save Monitor.

If your Aspecto deployment exposes the OTLP collector on a separate host or port, add a second TCP monitor:

# Find the collector's external address
kubectl get svc aspecto-collector -n aspecto -o jsonpath='{.status.loadBalancer.ingress[0].ip}'
# or for a NodePort:
kubectl get svc aspecto-collector -n aspecto -o jsonpath='{.spec.ports[0].nodePort}'

Create a TCP monitor for the collector's host and port (typically 4317 for gRPC OTLP or 4318 for HTTP OTLP) to independently verify that instrumented services can reach the ingestion layer.

Step 4: Configure alert channels

Email alerts

In Vigilmon, go to Alert Channels and click Add Channel.
Choose Email and enter the address for the platform team or on-call rotation (for example, observability-team@example.com).
Assign this channel to all Aspecto monitors created in Steps 2 and 3.
Click Save — Vigilmon will send a test email to confirm delivery.

Webhook alerts

For Slack, PagerDuty, or an internal alerting router:

In Alert Channels, click Add Channel and choose Webhook.
Paste your endpoint URL.
Vigilmon will POST the following JSON payload when a monitor transitions to down:

{
  "monitor_id": "mon_aspecto_api_health",
  "monitor_name": "Aspecto API /api/health",
  "status": "down",
  "previous_status": "up",
  "checked_at": "2026-07-12T14:22:17Z",
  "response_time_ms": null,
  "status_code": 503,
  "error": "Expected status 200, got 503",
  "url": "https://aspecto.example.com/api/health"
}

Assign all Aspecto monitors to this channel and click Save.

Runbook: kubectl diagnostics to run when an alert fires

#!/bin/bash
# Aspecto alert runbook — run these in order when Vigilmon fires

NAMESPACE=aspecto

echo "=== Pod status ==="
kubectl get pods -n $NAMESPACE

echo "=== API pod logs (last 100 lines) ==="
kubectl logs -n $NAMESPACE -l app=aspecto-api --tail=100

echo "=== Collector pod logs ==="
kubectl logs -n $NAMESPACE -l app=aspecto-collector --tail=50

echo "=== Health endpoint response ==="
curl -sv https://aspecto.example.com/api/health 2>&1 | tail -20

echo "=== Ingress status ==="
kubectl describe ingress -n $NAMESPACE

echo "=== Recent events ==="
kubectl get events -n $NAMESPACE --sort-by='.lastTimestamp' | tail -20

echo "=== TLS certificate expiry ==="
echo | openssl s_client -connect aspecto.example.com:443 \
  -servername aspecto.example.com 2>/dev/null \
  | openssl x509 -noout -enddate

echo "=== Node resource pressure ==="
kubectl describe nodes | grep -A5 "Conditions:"

Step 5: Create a public status page

A Vigilmon status page provides a single URL that your platform team, developers, and dependent teams can check during an Aspecto incident without needing Kubernetes or server access.

In Vigilmon, navigate to Status Pages and click New Status Page.
Give it a name such as Aspecto Tracing Platform and choose a subdomain like aspecto-status.vigilmon.page.
Add all monitors created in this tutorial: the /api/health HTTP monitor, the /v1/traces ingestion monitor, and the TCP port monitor.
Optionally add a description noting which service mesh or microservices depend on Aspecto for distributed tracing.
Click Publish — the page is immediately accessible and updates in real time.

Link this status page from your team's incident response runbook and from the README of each instrumented service so developers know where to check when traces stop appearing.

Putting it all together

| Monitor | Type | What it catches | |---|---|---| | https://aspecto.example.com/api/health | HTTP | API crash, database connectivity failure, storage saturation, process OOM kill | | https://aspecto.example.com/v1/traces | HTTP | Collector crash, ingestion endpoint failure, span processing errors | | aspecto.example.com:443 | TCP | Network connectivity loss, load balancer failure, TLS listener crash |

# Quick-reference diagnostic one-liners when a Vigilmon alert fires

# 1. Are all Aspecto pods running?
kubectl get pods -n aspecto | grep -v Running

# 2. What do the API pod logs show?
kubectl logs -n aspecto -l app=aspecto-api --tail=50 --since=5m

# 3. Can the health endpoint be reached?
curl -sf https://aspecto.example.com/api/health || echo "Health check FAILED"

# 4. Is the collector accepting spans?
curl -sf -X POST https://aspecto.example.com/v1/traces \
  -H "Content-Type: application/json" \
  -d '{"resourceSpans":[]}' || echo "Collector FAILED"

# 5. How long until the TLS cert expires?
echo | openssl s_client -connect aspecto.example.com:443 \
  -servername aspecto.example.com 2>/dev/null \
  | openssl x509 -noout -enddate

# 6. Are there node eviction events?
kubectl get events -n aspecto --field-selector reason=Evicted

What's next

SSL certificate monitoring — Aspecto's OTLP ingestion endpoint requires valid TLS for SDK exporters. Add a Vigilmon SSL monitor to alert you days before expiry and prevent a silent span-drop event across your entire fleet.
Synthetic trace heartbeat — Write a small script that sends a synthetic OpenTelemetry trace to Aspecto every five minutes and POSTs a heartbeat to a Vigilmon dead-man's-switch endpoint. If Aspecto stops receiving the synthetic trace, the heartbeat stops and Vigilmon fires an alert through a channel that does not depend on Aspecto being healthy.
Per-service ingestion monitors — If your services send traces to Aspecto through tenant-specific or environment-specific collector endpoints, add individual HTTP monitors for each endpoint so you can identify which environment is affected during a partial outage rather than knowing only that the platform is degraded.

Get started free at vigilmon.online — no credit card, monitors start running in under a minute.