Shopware Monitoring with Vigilmon

Shopware 6 Community Edition is the leading self-hosted PHP e-commerce alternative to commercetools and Magento in Germany and Europe. Built on Symfony with a Vue.js storefront and an API-first architecture supporting both REST and GraphQL, Shopware powers high-volume stores that rely on its message queue workers and scheduled task runner for critical background processing.

When a Shopware storefront goes down or its message queue stops processing, the impact goes beyond lost sales — queued order emails back up, stock levels don't sync, and search indexes go stale. This guide covers how to monitor Shopware with Vigilmon, including storefront availability, the REST API, the health endpoint, SSL certificates, and heartbeat monitoring for Shopware's background workers.

What to Monitor in a Shopware 6 Store

| Layer | URL Pattern | What Failure Means | |-------|-------------|-------------------| | Storefront homepage | https://yourstore.com/ | Customers can't browse or buy | | REST API | https://yourstore.com/api/_info/openapi3.json | API clients and integrations broken | | Health endpoint | https://yourstore.com/api/health | Platform-level health check failing | | SSL certificate | HTTPS on your domain | Browser warnings; checkout trust broken | | Message queue heartbeat | Symfony Messenger worker | Order emails, stock sync, search indexing backing up | | Task scheduler heartbeat | scheduled_task_runner worker | Scheduled cleanup and maintenance tasks failing |

Prerequisites

• A running Shopware 6 installation (6.4.x or 6.5.x) accessible over HTTPS
• A Vigilmon account
• Shopware API credentials (for REST API monitoring — created in Admin → Settings → System → Integrations)
• SSH access to your server (for heartbeat monitoring of workers)

Monitoring the Storefront

Step 1: Homepage Availability Monitor

1. Log in to Vigilmon → Monitors → New Monitor
2. Type: HTTP
3. Method: GET
4. URL: https://yourstore.com/
5. Interval: 1 minute
6. Keyword check: your store name or a product category name visible on the homepage

Shopware's Twig-rendered storefront can return a 200 with an error page when the database or Elasticsearch connection fails. A keyword check catches these "silent failure" responses that a plain HTTP status check would miss.

Step 2: Category Page Monitor

Add a monitor for a product listing page to detect search service failures (Elasticsearch or OpenSearch is required for Shopware's product search):

GET https://yourstore.com/navigation/your-category-id

Alternatively, use any category URL from your store. Add a keyword check for a product name visible in that category.

Monitoring the Shopware REST API

Shopware's API-first architecture means its REST API is the integration layer for ERPs, PIMs, and headless frontends. The OpenAPI spec endpoint is a lightweight way to verify the API is reachable without requiring authenticated requests.

Step 3: OpenAPI Spec Endpoint Monitor

The /api/_info/openapi3.json endpoint returns the Shopware API schema and requires no authentication:

1. Type: HTTP
2. Method: GET
3. URL: https://yourstore.com/api/_info/openapi3.json
4. Expected status: 200
5. Keyword check: "openapi" (the response is a JSON object with an openapi version field)

A healthy response begins with:

{
  "openapi": "3.0.0",
  "info": {
    "title": "Shopware API",
    ...
  }
}

For authenticated API monitoring (e.g., verifying your integration credentials work), use the OAuth token endpoint:

POST https://yourstore.com/api/oauth/token
Content-Type: application/json

{
  "client_id": "YOUR_CLIENT_ID",
  "client_secret": "YOUR_CLIENT_SECRET",
  "grant_type": "client_credentials"
}

Configure Vigilmon with the POST body above and a keyword check for "access_token".

Monitoring the Shopware Health Endpoint

Shopware 6.4+ includes a dedicated health check endpoint at /api/health that reports the status of platform dependencies.

Step 4: Health Check Endpoint Monitor

1. Type: HTTP
2. Method: GET
3. URL: https://yourstore.com/api/health
4. Expected status: 200
5. Keyword check: "status" or "ok"

A healthy response:

{
  "status": "ok"
}

If any registered health check service (database, cache, message queue connectivity) reports unhealthy, this endpoint returns a non-200 status. Monitoring it gives you a single-endpoint signal for platform health.

SSL Certificate Monitoring

Shopware stores typically run checkout flows under HTTPS. A lapsed certificate breaks checkout trust immediately and can fail automated API integrations that enforce certificate validation.

Step 5: SSL Certificate Alert

1. In Vigilmon, open your storefront homepage monitor
2. Navigate to SSL Certificate → Enable SSL monitoring
3. Warn at: 30 days before expiry
4. Critical at: 14 days before expiry

This is especially important for Shopware installations using Let's Encrypt certificates with auto-renewal — auto-renewal can silently fail if your Certbot or acme.sh renewal cron breaks.

Heartbeat Monitoring for Shopware Workers

Shopware 6 relies heavily on Symfony Messenger for asynchronous processing. Two long-running workers are critical:

Message queue workers (bin/console messenger:consume async) handle:

• Order confirmation and status emails
• Stock level updates after purchases
• Elasticsearch/OpenSearch product index updates

Scheduled task runner (bin/console scheduled-task:run) handles:

• Scheduled cleanup tasks (log cleanup, cart expiry)
• Automated maintenance operations registered by plugins

If these workers crash or stop being restarted — a common failure mode when supervisor or systemd units are misconfigured — processing backs up silently without any external error signal.

Step 6: Create Heartbeat Monitors

Create two separate heartbeat monitors in Vigilmon — one for the message queue worker and one for the scheduled task runner:

Message Queue Worker Heartbeat:

1. In Vigilmon → Monitors → New Monitor
2. Type: Heartbeat
3. Name: Shopware Message Queue Worker
4. Interval: 5 minutes

Scheduled Task Runner Heartbeat:

1. Type: Heartbeat
2. Name: Shopware Scheduled Task Runner
3. Interval: 60 minutes

Copy both generated heartbeat URLs.

Step 7: Wrap Workers with Heartbeat Pings

For supervisor-managed workers, add the heartbeat ping to the wrapper script or create a cron job that monitors the worker's liveness:

Using supervisor with a wrapper script (/usr/local/bin/shopware-worker-watch.sh):

#!/bin/bash
# Verify the messenger:consume process is running and ping heartbeat
if pgrep -f "messenger:consume" > /dev/null; then
    curl -fsS --retry 3 https://vigilmon.online/api/heartbeat/your-worker-token > /dev/null
fi

Add a cron job to run this check every 5 minutes:

*/5 * * * * /bin/bash /usr/local/bin/shopware-worker-watch.sh

For the scheduled task runner (typically run as a cron job):

# Run Shopware's scheduled task runner every hour
0 * * * * /usr/bin/php /var/www/shopware/bin/console scheduled-task:run >> /var/log/shopware-tasks.log 2>&1 && curl -fsS --retry 3 https://vigilmon.online/api/heartbeat/your-task-runner-token > /dev/null

Alerting Configuration

Alert Routing

• Storefront down: alert after 1 failed check — customers can't browse or buy
• API unavailable: alert after 2 failed checks
• Health endpoint failing: alert after 2 failed checks — indicates a platform dependency failure
• Message queue heartbeat missing: alert after 10 minutes — emails and index updates backing up
• Scheduled task heartbeat missing: alert after 90 minutes

Sample Alert (Message Queue Worker Down)

🔴 DOWN: Shopware Message Queue Worker
Monitor: Message Queue Heartbeat
Last ping: 12 minutes ago (expected every 5 minutes)
→ Check supervisor status: supervisorctl status shopware-worker
→ Check messenger:consume process: pgrep -f "messenger:consume"

Summary

| Monitor | URL | Check | Alert Threshold | |---------|-----|-------|-----------------| | Storefront homepage | / | Store keyword | 1 failed check | | REST API spec | /api/_info/openapi3.json | "openapi" | 2 failed checks | | Health endpoint | /api/health | "status" | 2 failed checks | | SSL certificate | HTTPS domain | Expiry threshold | 30 days warning | | Message queue worker | Vigilmon heartbeat URL | Ping every 5 min | 10 min without ping | | Scheduled task runner | Vigilmon heartbeat URL | Ping every hour | 90 min without ping |

With these monitors in place, you'll detect Shopware outages, API failures, and silently stopped background workers before they cascade into delayed order emails, stale search results, or unprocessed stock updates.

Further Reading

• Symfony Monitoring with Vigilmon
• Elasticsearch Monitoring with Vigilmon
• PrestaShop Monitoring with Vigilmon