Skip to content

Observability

make87 provides flexible observability options that work with your existing tools and workflows. The platform relies on Docker's standard logging. You can view these logs with docker logs or through the dashboard. For persistent collection or external analysis, you can optionally deploy log shippers such as Vector.

Logging

Standard Logging Approach

make87's logging is intentionally simple:

  • Docker-Native Logging: Applications write to stdout and stderr. These logs remain on the node and can be viewed with docker logs <container_id>.
  • Language Agnostic: Any programming language or library that can write to standard output streams works out of the box.
  • No Vendor Lock-in: Because logs are just Docker output, you can hook in any shipper or logging backend you like.

Centralized Log Viewing

For convenience during development and debugging, the make87 web dashboard provides a centralized view of logs from all applications across your system without any setup required.

Log Shipping & Aggregation

By default logs stay local to each node. For production environments you can aggregate them using a log shipper.

Node-Specific Log Collection

Since log shippers collect logs using docker logs, they can only access logs from applications running on the same node.

Multi-Node Systems: If your system spans multiple nodes, you need to deploy a log shipper application to each node that has applications you want to collect logs from.

Example: A system with 3 nodes running applications requires 3 separate log shipper deployments (one per node) to collect logs from all applications.

Using the Vector Log Shipper

make87 provides an optional but powerful Vector application that can be deployed into your system. It automatically connects to the Docker daemon on its node, collects logs from all other running applications, and can forward them to various destinations.

The Vector application exposes multiple interfaces for maximum flexibility:

Interface Protocol Common Destinations
vector-http HTTP (port 8686) Grafana Loki, Elasticsearch, Prometheus remote‑write
vector-grpc OTLP gRPC (port 4317) OpenTelemetry backends
vector-tcp TCP/UDP (port 9000) Socket collectors, custom parsers

Building a Custom Log Shipper

You are not required to use the provided Vector application. You can build and deploy your own custom log shipper application.

To do this, your application's container will need access to the Docker daemon socket. This can be configured in your MAKE87.yml:

container_config:
  volumes:
    - "/var/run/docker.sock:/var/run/docker.sock"

With access to the socket, your custom application can use the Docker Engine API to stream logs from other containers on the same node.

Ready-to-Use Visualization

To complete your logging stack, you can deploy pre-built applications for visualization and analysis:

  • Grafana/Loki: Deploy Grafana with a Loki backend for powerful log querying and dashboarding.
  • Rerun: Use the Rerun application for time-series visualization, which is particularly useful in robotics and for sensor data.
  • Custom Solutions: Ingest logs into your own data stores or visualization tools.

Metrics & Monitoring

Node & Application Metrics

make87 automatically gathers and displays key health metrics in the dashboard:

  • Node Metrics: CPU usage, memory usage, disk space, and network status.
  • Application Metrics: Container status, health checks, and resource consumption (CPU/memory).

Custom Metrics

For application-specific metrics, you can use any standard format and expose it via a communication interface.

  • Prometheus: The most common approach is to expose a /metrics endpoint using an HTTP server interface. You can then deploy a Prometheus application to scrape this endpoint.
  • OpenTelemetry: Use the OTLP protocol to export metrics and traces from your application to a collector.
  • Custom Protocols: Send metrics over any protocol (e.g., MQTT, Zenoh) to a custom monitoring application.

Best Practices

  • Development: Use the built-in dashboard log viewer for quick, real-time feedback.
  • Staging/Production: Deploy a log aggregation stack (e.g., Vector + Loki/Grafana) for persistent, searchable logs.
  • Structured Logging: Write logs in a structured format like JSON. This makes them much easier to parse, filter, and analyze in your logging backend.
  • Health Checks: Implement health checks in your MAKE87.yml to ensure the platform can automatically manage the state of your application.