feat: [#238] integrate Prometheus with Docker Compose

- Add prometheus_config field to DockerComposeContext
- Implement with_prometheus() builder method
- Add conditional Prometheus service to docker-compose.yml.tera
- Use bind mount for Prometheus config: ./storage/prometheus/etc:/etc/prometheus:Z
- Add 4 unit tests for Prometheus service rendering (with/without config)
- All linters passing

Author: josecelano

docs/issues/238-prometheus-slice-release-run-commands.md

@@ -33,13 +33,24 @@ This task adds Prometheus as a metrics collection service for the Torrust Tracke
   - Implemented comprehensive unit tests (5 tests)
   - Updated all constructors and test fixtures
 
-- 🚧 **Phase 3**: Prometheus Template Renderer (in progress)
+- ✅ **Phase 3**: Prometheus Template Renderer (commit: 731eaf4)
 
-  - Create `PrometheusProjectGenerator` implementation
-  - Integrate with template rendering system
-  - Wire up data flow: UserInputs → PrometheusContext → Template
+  - Created `PrometheusConfigRenderer` to load and render `prometheus.yml.tera`
+  - Implemented `PrometheusTemplate` wrapper for Tera integration
+  - Created `PrometheusProjectGenerator` to orchestrate rendering workflow
+  - Implemented context extraction from `PrometheusConfig` and `TrackerConfig`
+  - Added 12 comprehensive unit tests with full coverage
+  - All linters passing
+
+- ✅ **Phase 4**: Docker Compose Integration (commit: pending)
+
+  - Added `prometheus_config: Option<PrometheusConfig>` field to `DockerComposeContext`
+  - Implemented `with_prometheus()` method for context builder pattern
+  - Added conditional Prometheus service to `docker-compose.yml.tera` template
+  - Prometheus service uses bind mount: `./storage/prometheus/etc:/etc/prometheus:Z`
+  - Added 4 comprehensive unit tests for Prometheus service rendering
+  - All linters passing
 
-- ⏳ **Phase 4**: Docker Compose Integration (pending)
 - ⏳ **Phase 5**: Release Command Implementation (pending)
 - ⏳ **Phase 6**: Ansible Playbook Integration (pending)
 - ⏳ **Phase 7**: Testing (pending)

src/infrastructure/templating/docker_compose/template/renderer/docker_compose.rs

@@ -337,4 +337,117 @@ mod tests {
             "Should not contain mysql_data volume"
         );
     }
+
+    #[test]
+    fn it_should_render_prometheus_service_when_config_is_present() {
+        use crate::domain::prometheus::PrometheusConfig;
+
+        let temp_dir = TempDir::new().unwrap();
+        let template_manager = Arc::new(TemplateManager::new(temp_dir.path()));
+
+        let ports = TrackerPorts {
+            udp_tracker_ports: vec![6868, 6969],
+            http_tracker_ports: vec![7070],
+            http_api_port: 1212,
+        };
+        let prometheus_config = PrometheusConfig {
+            scrape_interval: 15,
+        };
+        let context = DockerComposeContext::new_sqlite(ports).with_prometheus(prometheus_config);
+
+        let renderer = DockerComposeRenderer::new(template_manager);
+        let output_dir = TempDir::new().unwrap();
+
+        let result = renderer.render(&context, output_dir.path());
+        assert!(
+            result.is_ok(),
+            "Rendering with Prometheus context should succeed"
+        );
+
+        let output_path = output_dir.path().join("docker-compose.yml");
+        let rendered_content = std::fs::read_to_string(&output_path)
+            .expect("Should be able to read rendered docker-compose.yml");
+
+        // Verify Prometheus service is present
+        assert!(
+            rendered_content.contains("prometheus:"),
+            "Rendered output should contain prometheus service"
+        );
+        assert!(
+            rendered_content.contains("image: prom/prometheus:v3.0.1"),
+            "Should use Prometheus v3.0.1 image"
+        );
+        assert!(
+            rendered_content.contains("container_name: prometheus"),
+            "Should set container name"
+        );
+
+        // Verify port mapping
+        assert!(
+            rendered_content.contains("9090:9090"),
+            "Should expose Prometheus port 9090"
+        );
+
+        // Verify volume mount
+        assert!(
+            rendered_content.contains("./storage/prometheus/etc:/etc/prometheus:Z"),
+            "Should mount Prometheus config directory"
+        );
+
+        // Verify service dependency
+        assert!(
+            rendered_content.contains("depends_on:"),
+            "Should have depends_on section"
+        );
+        assert!(
+            rendered_content.contains("- tracker"),
+            "Should depend on tracker"
+        );
+
+        // Verify network
+        assert!(
+            rendered_content.contains("- backend_network"),
+            "Should be on backend_network"
+        );
+    }
+
+    #[test]
+    fn it_should_not_render_prometheus_service_when_config_is_absent() {
+        let temp_dir = TempDir::new().unwrap();
+        let template_manager = Arc::new(TemplateManager::new(temp_dir.path()));
+
+        let ports = TrackerPorts {
+            udp_tracker_ports: vec![6868, 6969],
+            http_tracker_ports: vec![7070],
+            http_api_port: 1212,
+        };
+        let context = DockerComposeContext::new_sqlite(ports);
+
+        let renderer = DockerComposeRenderer::new(template_manager);
+        let output_dir = TempDir::new().unwrap();
+
+        let result = renderer.render(&context, output_dir.path());
+        assert!(
+            result.is_ok(),
+            "Rendering without Prometheus context should succeed"
+        );
+
+        let output_path = output_dir.path().join("docker-compose.yml");
+        let rendered_content = std::fs::read_to_string(&output_path)
+            .expect("Should be able to read rendered docker-compose.yml");
+
+        // Verify Prometheus service is NOT present
+        assert!(
+            !rendered_content.contains("image: prom/prometheus:v3.0.1"),
+            "Should not contain Prometheus service when config absent"
+        );
+        assert!(
+            !rendered_content.contains("container_name: prometheus"),
+            "Should not have prometheus container"
+        );
+        assert!(
+            !rendered_content.contains("./storage/prometheus/etc:/etc/prometheus:Z"),
+            "Should not have prometheus volume mount"
+        );
+    }
 }

src/infrastructure/templating/docker_compose/template/wrappers/docker_compose/context.rs

@@ -5,6 +5,8 @@
 
 use serde::Serialize;
 
+use crate::domain::prometheus::PrometheusConfig;
+
 /// Tracker port configuration
 #[derive(Debug, Clone)]
 pub struct TrackerPorts {
@@ -54,6 +56,9 @@ pub struct DockerComposeContext {
     pub http_tracker_ports: Vec<u16>,
     /// HTTP API port
     pub http_api_port: u16,
+    /// Prometheus configuration (optional)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub prometheus_config: Option<PrometheusConfig>,
 }
 
 impl DockerComposeContext {
@@ -86,6 +91,7 @@ impl DockerComposeContext {
             udp_tracker_ports: ports.udp_tracker_ports,
             http_tracker_ports: ports.http_tracker_ports,
             http_api_port: ports.http_api_port,
+            prometheus_config: None,
         }
     }
 
@@ -143,9 +149,21 @@ impl DockerComposeContext {
             udp_tracker_ports: ports.udp_tracker_ports,
             http_tracker_ports: ports.http_tracker_ports,
             http_api_port: ports.http_api_port,
+            prometheus_config: None,
         }
     }
 
+    /// Add Prometheus configuration to the context
+    ///
+    /// # Arguments
+    ///
+    /// * `prometheus_config` - Prometheus configuration
+    #[must_use]
+    pub fn with_prometheus(mut self, prometheus_config: PrometheusConfig) -> Self {
+        self.prometheus_config = Some(prometheus_config);
+        self
+    }
+
     /// Get the database configuration
     #[must_use]
     pub fn database(&self) -> &DatabaseConfig {
@@ -169,6 +187,12 @@ impl DockerComposeContext {
     pub fn http_api_port(&self) -> u16 {
         self.http_api_port
     }
+
+    /// Get the Prometheus configuration if present
+    #[must_use]
+    pub fn prometheus_config(&self) -> Option<&PrometheusConfig> {
+        self.prometheus_config.as_ref()
+    }
 }
 
 impl DatabaseConfig {
@@ -294,4 +318,62 @@ mod tests {
         let cloned = context.clone();
         assert_eq!(cloned.database().driver(), "mysql");
     }
+
+    #[test]
+    fn it_should_not_include_prometheus_config_by_default() {
+        let ports = TrackerPorts {
+            udp_tracker_ports: vec![6868, 6969],
+            http_tracker_ports: vec![7070],
+            http_api_port: 1212,
+        };
+        let context = DockerComposeContext::new_sqlite(ports);
+
+        assert!(context.prometheus_config().is_none());
+    }
+
+    #[test]
+    fn it_should_include_prometheus_config_when_added() {
+        let ports = TrackerPorts {
+            udp_tracker_ports: vec![6868, 6969],
+            http_tracker_ports: vec![7070],
+            http_api_port: 1212,
+        };
+        let prometheus_config = PrometheusConfig {
+            scrape_interval: 30,
+        };
+        let context = DockerComposeContext::new_sqlite(ports).with_prometheus(prometheus_config);
+
+        assert!(context.prometheus_config().is_some());
+        assert_eq!(context.prometheus_config().unwrap().scrape_interval, 30);
+    }
+
+    #[test]
+    fn it_should_not_serialize_prometheus_config_when_absent() {
+        let ports = TrackerPorts {
+            udp_tracker_ports: vec![6868, 6969],
+            http_tracker_ports: vec![7070],
+            http_api_port: 1212,
+        };
+        let context = DockerComposeContext::new_sqlite(ports);
+
+        let serialized = serde_json::to_string(&context).unwrap();
+        assert!(!serialized.contains("prometheus_config"));
+    }
+
+    #[test]
+    fn it_should_serialize_prometheus_config_when_present() {
+        let ports = TrackerPorts {
+            udp_tracker_ports: vec![6868, 6969],
+            http_tracker_ports: vec![7070],
+            http_api_port: 1212,
+        };
+        let prometheus_config = PrometheusConfig {
+            scrape_interval: 20,
+        };
+        let context = DockerComposeContext::new_sqlite(ports).with_prometheus(prometheus_config);
+
+        let serialized = serde_json::to_string(&context).unwrap();
+        assert!(serialized.contains("prometheus_config"));
+        assert!(serialized.contains("\"scrape_interval\":20"));
+    }
 }

templates/docker-compose/docker-compose.yml.tera

@@ -57,6 +57,26 @@ services:
         max-size: "10m"
         max-file: "10"
 
+{% if prometheus_config %}
+  prometheus:
+    image: prom/prometheus:v3.0.1
+    container_name: prometheus
+    tty: true
+    restart: unless-stopped
+    networks:
+      - backend_network
+    ports:
+      - "9090:9090"
+    volumes:
+      - ./storage/prometheus/etc:/etc/prometheus:Z
+    logging:
+      options:
+        max-size: "10m"
+        max-file: "10"
+    depends_on:
+      - tracker
+{% endif %}
+
 {% if database.driver == "mysql" %}
   mysql:
     image: mysql:8.0