Engula

Monitoring Engula with Redis Ecosystem Tools

Overview

Engula is fully Redis/Valkey 7.2 protocol compatible, enabling seamless monitoring using the entire Redis ecosystem. This guide details how to monitor Engula using Redis Exporter, Prometheus, and Grafana with popular Redis dashboard templates.

Key Advantage: Redis Ecosystem Compatibility

Since Engula implements the Redis protocol, you can use all existing Redis monitoring tools without any modifications. This means instant access to:

Proven monitoring solutions tested by millions of Redis users
Extensive dashboard templates with comprehensive metrics
Mature alerting rules and best practices
Community support and documentation

Architecture

┌─────────────┐    ┌────────────────┐    ┌─────────────┐    ┌─────────────┐
│   Engula    │───▶│ Redis Exporter │───▶│ Prometheus  │───▶│   Grafana   │
│   Server(s) │    │ (oliver006)    │    │   Server    │    │  Dashboard  │
└─────────────┘    └────────────────┘    └─────────────┘    └─────────────┘
     6379               9121                9090               3000

Quick Start - Docker Compose

For rapid deployment, use this Docker Compose configuration:

1# docker-compose.yml
2version: '3.8'
3
4services:
5  # Redis Exporter for Engula monitoring
6  redis-exporter:
7    image: oliver006/redis_exporter:latest
8    container_name: engula-redis-exporter
9    restart: unless-stopped
10    ports:
11      - "9121:9121"
12    environment:
13      - REDIS_ADDR=redis://engula-server:6379
14    command:
15      - '-redis.addr=redis://engula-server:6379'
16    networks:
17      - monitoring
18
19  # Prometheus Server
20  prometheus:
21    image: prom/prometheus:latest
22    container_name: engula-prometheus
23    restart: unless-stopped
24    ports:
25      - "9090:9090"
26    volumes:
27      - ./prometheus.yml:/etc/prometheus/prometheus.yml
28      - prometheus_data:/prometheus
29    command:
30      - '--config.file=/etc/prometheus/prometheus.yml'
31      - '--storage.tsdb.path=/prometheus'
32      - '--storage.tsdb.retention.time=200h'
33      - '--web.enable-lifecycle'
34    networks:
35      - monitoring
36
37  # Grafana Dashboard
38  grafana:
39    image: grafana/grafana:latest
40    container_name: engula-grafana
41    restart: unless-stopped
42    ports:
43      - "3000:3000"
44    environment:
45      - GF_SECURITY_ADMIN_USER=admin
46      - GF_SECURITY_ADMIN_PASSWORD=admin123
47    volumes:
48      - grafana_data:/var/lib/grafana
49    networks:
50      - monitoring
51
52volumes:
53  prometheus_data:
54  grafana_data:
55
56networks:
57  monitoring:
58    driver: bridge
59
60# Note: Replace 'engula-server:6379' with your actual Engula server address

Deploy with:

1docker-compose up -d

Component Setup

1. Redis Exporter Configuration

The Redis Exporter connects to Engula using the Redis protocol and exposes metrics in Prometheus format.

Docker Deployment

1# Single Engula instance
2docker run -d \
3  --name engula-redis-exporter \
4  -p 9121:9121 \
5  oliver006/redis_exporter:latest \
6  -redis.addr=redis://localhost:6379
7
8# Multiple Engula instances
9docker run -d \
10  --name multi-redis-exporter \
11  -p 9121:9121 \
12  oliver006/redis_exporter:latest \
13  -redis.addr=redis://engula-1:6379,redis://engula-2:6379,redis://engula-3:6379
14
15# With authentication
16docker run -d \
17  --name secure-redis-exporter \
18  -p 9121:9121 \
19  oliver006/redis_exporter:latest \
20  -redis.addr=redis://engula-secure:6379 \
21  -redis.password=your-password

Important Exporter Parameters

Parameter	Description	Example
`-redis.addr`	Engula server address	`redis://localhost:6379`
`-redis.password`	Authentication password	`-redis.password=mypass123`
`-namespace`	Metrics namespace	`-namespace=engula`
`-web.listen-address`	Exporter listen port	`-web.listen-address=:9121`

Verify Exporter Works with Engula

1# Check exporter is running
2curl http://localhost:9121/metrics
3
4# You should see Redis metrics like:
5# redis_connected_clients 15
6# redis_memory_used_bytes 1048576
7# redis_keyspace_hits_total 1234

2. Prometheus Configuration

Create prometheus.yml to collect metrics from the Redis Exporter:

1global:
2  scrape_interval: 15s
3  evaluation_interval: 15s
4
5scrape_configs:
6  # Engula monitoring via Redis Exporter
7  - job_name: 'engula'
8    static_configs:
9      - targets: ['redis-exporter:9121']
10    scrape_interval: 15s
11    metrics_path: /metrics
12
13  # Multiple Engula instances (if needed)
14  - job_name: 'engula-cluster'
15    static_configs:
16      - targets:
17        - 'engula-exporter-1:9121'
18        - 'engula-exporter-2:9121'
19        - 'engula-exporter-3:9121'
20    scrape_interval: 15s

Deploy Prometheus

1# Create config directory
2mkdir -p grafana-prometheus
3cd grafana-prometheus
4
5# Create prometheus.yml with content above
6
7# Deploy via Docker
8docker run -d \
9  --name prometheus \
10  -p 9090:9090 \
11  -v $(pwd)/prometheus.yml:/etc/prometheus/prometheus.yml \
12  prom/prometheus:latest
13
14# Verify
15curl http://localhost:9090/targets

3. Grafana Setup

Deploy Grafana

1docker run -d \
2  --name grafana \
3  -p 3000:3000 \
4  -e "GF_SECURITY_ADMIN_PASSWORD=admin123" \
5  grafana/grafana:latest

Access Grafana at http://localhost:3000 (admin/admin123).

Configure Prometheus Data Source

Login to Grafana → Configuration → Data Sources
Add data source → Prometheus
Name: Engula-Prometheus
URL: http://prometheus:9090 (or http://localhost:9090 for local setup)
Save & Test

Popular Redis Dashboard Templates for Engula

Redis Dashboard for Prometheus (Recommended)

Dashboard ID: 763
Author: oliver006 (same as Redis Exporter)

Import Dashboard

Grafana → + → Import
Enter Dashboard ID: 763
Load Dashboard
Select Prometheus data source: Engula-Prometheus
Import

Dashboard Features

This dashboard provides comprehensive monitoring including:

Instance Overview

Total connected clients
Memory usage (used/max)
Hit rate percentage
Commands per second
Network I/O

Performance Metrics

Response time distribution
Slow queries count
Keyspace operations
CPU usage

Memory Analysis

Memory breakdown by data type
Key distribution
Memory fragmentation
Eviction policies

Network Statistics

Input/output throughput
Connection breakdown
Network errors

Health Indicators

Uptime
Replication status
Server information

Key Metrics Available for Engula

Since Engula is Redis-compatible, all standard Redis metrics are exposed:

Performance Metrics

1# Commands per second
2rate(redis_commands_processed_total[5m])
3
4# Connections
5redis_connected_clients
6
7# Memory usage
8redis_memory_used_bytes
9redis_memory_max_bytes
10
11# Hit rate
12(redis_keyspace_hits_total / (redis_keyspace_hits_total + redis_keyspace_misses_total)) * 100

Data Type Metrics

1# Keys by database
2redis_db_keys{db="0"}
3
4# Expired keys
5increase(redis_expired_keys_total[5m])
6
7# Evicted keys
8increase(redis_evicted_keys_total[5m])

Network Metrics

1# Network input rate
2rate(redis_net_input_bytes_total[5m])
3
4# Network output rate  
5rate(redis_net_output_bytes_total[5m])

Production Deployment Example

Monitoring Multiple Engula Instances

1# prometheus.yml
2global:
3  scrape_interval: 10s
4
5scrape_configs:
6  - job_name: 'engula-prod-cluster'
7    static_configs:
8      - targets:
9        - 'prod-exporter-1.company.com:9121'
10        - 'prod-exporter-2.company.com:9121'
11        - 'prod-exporter-3.company.com:9121'
12    metrics_path: /metrics
13    scrape_interval: 10s
14    relabel_configs:
15      - source_labels: [__address__]
16        target_label: instance
17        regex: '([^:]+):.*'
18        replacement: '$1'

Verification and Testing

1. Verify Metrics Collection

1# Check Redis Exporter metrics
2curl http://localhost:9121/metrics | grep redis_memory_used
3
4# Verify Prometheus targets
5curl http://localhost:9090/api/v1/targets
6
7# Test Prometheus queries
8curl 'http://localhost:9090/api/v1/query?query=redis_connected_clients'

Best Practices

1. Monitoring Configuration

Scrape Interval: 15-30 seconds for most use cases
Retention: 15-30 days for production monitoring
Storage: Allocate sufficient disk space for metrics history

2. Performance Considerations

Monitor exporter overhead (typically negligible)
Use appropriate Prometheus memory limits
Consider metric sampling for high-cardinality data

3. Security

Use authentication for production deployments
Network isolation between components
SSL/TLS for external communications

Additional Resources

Official Documentation

Community Resources

Engula-Specific Support

Engula maintains full compatibility with Redis monitoring tools
All existing Redis dashboards work without modification
No custom exporters or metrics required

Summary

By leveraging Engula's Redis protocol compatibility, you gain immediate access to the mature Redis monitoring ecosystem:

Deploy Redis Exporter to collect metrics from Engula
Configure Prometheus to store and query metrics
Import proven Redis dashboards in Grafana
Monitor production workloads with enterprise-grade tools

This approach provides immediate, reliable monitoring without any Engula-specific customization required.

Note: All configurations use standard Redis monitoring tools. No modifications are needed for Engula-specific features due to the protocol compatibility.

Engula

Monitoring Engula with Redis Ecosystem Tools#

Overview#

Key Advantage: Redis Ecosystem Compatibility#

Architecture#

Quick Start - Docker Compose#

Component Setup#

1. Redis Exporter Configuration#

Docker Deployment#

Important Exporter Parameters#

Verify Exporter Works with Engula#

2. Prometheus Configuration#

Deploy Prometheus#

3. Grafana Setup#

Deploy Grafana#

Configure Prometheus Data Source#

Popular Redis Dashboard Templates for Engula#

Redis Dashboard for Prometheus (Recommended)#

Import Dashboard#

Dashboard Features#

Key Metrics Available for Engula#

Performance Metrics#

Data Type Metrics#

Network Metrics#

Production Deployment Example#

Monitoring Multiple Engula Instances#

Verification and Testing#

1. Verify Metrics Collection#

Best Practices#

1. Monitoring Configuration#

2. Performance Considerations#

3. Security#

Additional Resources#

Official Documentation#

Community Resources#

Engula-Specific Support#

Summary#