Monitoring Redis logs with ClickStack

Monitoring Redis Logs with ClickStack

Monitoring Redis Logs with ClickStack

TL;DR

Collect and visualize Redis server logs in ClickStack using the OTel filelog receiver. Includes a demo dataset and pre-built dashboard.

Integration with existing Redis

This section covers configuring your existing Redis installation to send logs to ClickStack by modifying the ClickStack OTel collector configuration. If you would like to test the Redis integration before configuring your own existing setup, you can test with our preconfigured setup and sample data in the “Demo dataset” section.

Prerequisites

• ClickStack instance running
• Existing Redis installation (version 3.0 or newer)
• Access to Redis log files

1. Verify Redis logging configuration

   First, check your Redis logging configuration. Connect to Redis and check the log file location:

   redis-cli CONFIG GET logfile
   

   Common Redis log locations:

   • Linux (apt/yum): /var/log/redis/redis-server.log
   • macOS (Homebrew): /usr/local/var/log/redis.log
   • Docker: Often logged to stdout, but can be configured to write to /data/redis.log

   If Redis is logging to stdout, configure it to write to a file by updating redis.conf:

   # Log to file instead of stdout
   logfile /var/log/redis/redis-server.log
   
   # Set log level (options: debug, verbose, notice, warning)
   loglevel notice
   

   After changing the configuration, restart Redis:

   # For systemd
   sudo systemctl restart redis
   
   # For Docker
   docker restart <redis-container>
   
2. Create custom OTel collector configuration

   ClickStack allows you to extend the base OpenTelemetry Collector configuration by mounting a custom configuration file and setting an environment variable. The custom configuration is merged with the base configuration managed by HyperDX via OpAMP.

   Create a file named redis-monitoring.yaml with the following configuration:

   receivers:
     filelog/redis:
       include:
         - /var/log/redis/redis-server.log
       start_at: beginning
       operators:
         - type: regex_parser
           regex: '^(?P\d+):(?P\w+) (?P\d{2} \w+ \d{4} \d{2}:\d{2}:\d{2})\.\d+ (?P[.\-*#]) (?P.*)$'
           parse_from: body
           parse_to: attributes
         
         - type: time_parser
           parse_from: attributes.timestamp
           layout: '%d %b %Y %H:%M:%S'
         
         - type: add
           field: attributes.source
           value: "redis"
         
         - type: add
           field: resource["service.name"]
           value: "redis-production"
   
   service:
     pipelines:
       logs/redis:
         receivers: [filelog/redis]
         processors:
           - memory_limiter
           - transform
           - batch
         exporters:
           - clickhouse
   

   This configuration:

   • Reads Redis Logs from their standard location
   • Parses Redis’s log format using regex to extract structured fields (pid, role, timestamp, log_level, message)
   • Adds source: redis attribute for filtering in HyperDX
   • Routes logs to the ClickHouse exporter via a dedicated pipeline

   • You only define new receivers and pipelines in the custom config
   • The processors (memory_limiter, transform, batch) and exporters (clickhouse) are already defined in the base ClickStack configuration - you just reference them by name
   • The time_parser operator extracts timestamps from Redis Logs to preserve original log timing
   • This configuration uses start_at: beginning to read all existing logs when the collector starts, allowing you to see logs immediately. For production deployments where you want to avoid re-ingesting logs on collector restarts, change to start_at: end.
3. Configure ClickStack to load custom configuration

   To enable custom collector configuration in your existing ClickStack deployment, you must:

   1. Mount the custom config file at /etc/otelcol-contrib/custom.config.yaml
   2. Set the environment variable CUSTOM_OTELCOL_CONFIG_FILE=/etc/otelcol-contrib/custom.config.yaml
   3. Mount your Redis log directory so the collector can read them

   Update your ClickStack deployment configuration:

   services:
     clickstack:
       # ... existing configuration ...
       environment:
         - CUSTOM_OTELCOL_CONFIG_FILE=/etc/otelcol-contrib/custom.config.yaml
         # ... other environment variables ...
       volumes:
         - ./redis-monitoring.yaml:/etc/otelcol-contrib/custom.config.yaml:ro
         - /var/log/redis:/var/log/redis:ro
         # ... other volumes ...
   

   If you’re using the all-in-one image with docker, run:

   docker run --name clickstack \
     -p 8080:8080 -p 4317:4317 -p 4318:4318 \
     -e CUSTOM_OTELCOL_CONFIG_FILE=/etc/otelcol-contrib/custom.config.yaml \
     -v "$(pwd)/redis-monitoring.yaml:/etc/otelcol-contrib/custom.config.yaml:ro" \
     -v /var/log/redis:/var/log/redis:ro \
     clickhouse/clickstack-all-in-one:latest
   

   Ensure the ClickStack collector has appropriate permissions to read the Redis log files. In production, use read-only mounts (:ro) and follow the principle of least privilege.

4. Verifying Logs in HyperDX

   Once configured, log into HyperDX and verify that logs are flowing:

Demo dataset

For users who want to test the Redis integration before configuring their production systems, we provide a sample dataset of pre-generated Redis Logs with realistic patterns.

1. Download the sample dataset

   Download the sample log file:

   curl -O https://datasets-documentation.s3.eu-west-3.amazonaws.com/clickstack-integrations/redis/redis-server.log
   
2. Create test collector configuration

   Create a file named redis-demo.yaml with the following configuration:

   cat > redis-demo.yaml << 'EOF'
   receivers:
     filelog/redis:
       include:
         - /tmp/redis-demo/redis-server.log
       start_at: beginning  # Read from beginning for demo data
       operators:
         - type: regex_parser
           regex: '^(?P<pid>\d+):(?P<role>\w+) (?P<timestamp>\d{2} \w+ \d{4} \d{2}:\d{2}:\d{2})\.\d+ (?P<log_level>[.\-*#]) (?P<message>.*)$'
           parse_from: body
           parse_to: attributes
         
         - type: time_parser
           parse_from: attributes.timestamp
           layout: '%d %b %Y %H:%M:%S'
         
         - type: add
           field: attributes.source
           value: "redis-demo"
         
         - type: add
           field: resource["service.name"]
           value: "redis-demo"
   
   service:
     pipelines:
       logs/redis-demo:
         receivers: [filelog/redis]
         processors:
           - memory_limiter
           - transform
           - batch
         exporters:
           - clickhouse
   EOF
   
3. Run ClickStack with demo configuration

   Run ClickStack with the demo logs and configuration:

   docker run --name clickstack-demo \
     -p 8080:8080 -p 4317:4317 -p 4318:4318 \
     -e CUSTOM_OTELCOL_CONFIG_FILE=/etc/otelcol-contrib/custom.config.yaml \
     -v "$(pwd)/redis-demo.yaml:/etc/otelcol-contrib/custom.config.yaml:ro" \
     -v "$(pwd)/redis-server.log:/tmp/redis-demo/redis-server.log:ro" \
     clickhouse/clickstack-all-in-one:latest
   

   This mounts the log file directly into the container. This is done for testing purposes with static demo data.

   Verify logs in HyperDX

   Once ClickStack is running:

   1. Open HyperDX and log in to your account (you may need to create an account first)
   2. Navigate to the Search view and set the source to Logs
   3. Set the time range to 2025-10-26 10:00:00 - 2025-10-29 10:00:00

   Timezone Display

   HyperDX displays timestamps in your browser’s local timezone. The demo data spans 2025-10-27 10:00:00 - 2025-10-28 10:00:00 (UTC). The wide time range ensures you’ll see the demo logs regardless of your location. Once you see the logs, you can narrow the range to a 24-hour period for clearer visualizations.

Dashboards and visualization

To help you get started monitoring Redis with ClickStack, we provide essential visualizations for Redis Logs.

1. the dashboard configuration

2. Import Pre-built Dashboard

   1. Open HyperDX and navigate to the Dashboards section.
   2. Click “Import Dashboard” in the upper right corner under the ellipses.

   3. Upload the redis-logs-dashboard.json file and click finish import.
3. The dashboard will be created with all visualizations pre-configured

   For the demo dataset, set the time range to 2025-10-27 10:00:00 - 2025-10-28 10:00:00 (UTC) (adjust based on your local timezone). The imported dashboard won’t have a time range specified by default.

Troubleshooting

Custom config not loading

Verify the environment variable is set correctly:

docker exec <container-name> printenv CUSTOM_OTELCOL_CONFIG_FILE
# Expected output: /etc/otelcol-contrib/custom.config.yaml

Check that the custom config file is mounted:

docker exec <container-name> ls -lh /etc/otelcol-contrib/custom.config.yaml
# Expected output: Should show file size and permissions

View the custom config content:

docker exec <container-name> cat /etc/otelcol-contrib/custom.config.yaml
# Should display your redis-monitoring.yaml content

Check the effective config includes your filelog receiver:

docker exec <container> cat /etc/otel/supervisor-data/effective.yaml | grep -A 10 filelog
# Should show your filelog/redis receiver configuration

No logs appearing in HyperDX

Ensure Redis is writing logs to a file:

redis-cli CONFIG GET logfile
# Expected output: Should show a file path, not empty string
# Example: 1) "logfile" 2) "/var/log/redis/redis-server.log"

Check Redis is actively logging:

tail -f /var/log/redis/redis-server.log
# Should show recent log entries in Redis format

Verify the collector can read the logs:

docker exec <container> cat /var/log/redis/redis-server.log
# Should display Redis log entries

Check for errors in the collector logs:

docker exec <container> cat /etc/otel/supervisor-data/agent.log
# Look for any error messages related to filelog or Redis

If using docker-compose, verify shared volumes:

# Check both containers are using the same volume
docker volume inspect <volume-name>
# Verify both containers have the volume mounted

Logs not parsing correctly

Verify Redis log format matches expected pattern:

# Redis Logs should look like:
# 12345:M 28 Oct 2024 14:23:45.123 * Server started
tail -5 /var/log/redis/redis-server.log

If your Redis Logs have a different format, you may need to adjust the regex pattern in the regex_parser operator. The standard format is:

• pid:role timestamp level message
• Example: 12345:M 28 Oct 2024 14:23:45.123 * Server started

Next steps

• Set up alerts for critical metrics (error rates, latency thresholds)
• Create additional dashboards for specific use cases (API monitoring, security events)

Going to production

This guide extends ClickStack’s built-in OpenTelemetry Collector for quick setup. For production deployments, we recommend running your own OTel Collector and sending data to ClickStack’s OTLP endpoint. See Sending OpenTelemetry data for production configuration.