feat: [#238] add independent Prometheus template rendering in release workflow

- Create RenderPrometheusTemplatesStep for Prometheus config rendering
- Add render_prometheus_templates() method to ReleaseCommandHandler
- Prometheus templates rendered independently at Step 5 (after tracker, before docker-compose)
- Add RenderPrometheusTemplates variant to ReleaseStep enum
- Extend EnvironmentTestBuilder with with_prometheus_config() method
- Export PrometheusProjectGeneratorError from prometheus module
- Fix architectural issue: Each service now renders its templates independently
- Docker Compose step only adds Prometheus config to context (no template rendering)

This follows the architectural principle that each service should render
its templates independently in the release handler. Docker Compose templates
are NOT the master templates - they only define service orchestration.
The environment configuration is the source of truth for which services
are enabled.

All tests passing (1507 tests), all linters passing.

Author: josecelano

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

@@ -42,7 +42,7 @@ This task adds Prometheus as a metrics collection service for the Torrust Tracke
   - Added 12 comprehensive unit tests with full coverage
   - All linters passing
 
-- ✅ **Phase 4**: Docker Compose Integration (commit: pending)
+- ✅ **Phase 4**: Docker Compose Integration (commit: 22790de)
 
   - Added `prometheus_config: Option<PrometheusConfig>` field to `DockerComposeContext`
   - Implemented `with_prometheus()` method for context builder pattern
@@ -51,7 +51,19 @@ This task adds Prometheus as a metrics collection service for the Torrust Tracke
   - Added 4 comprehensive unit tests for Prometheus service rendering
   - All linters passing
 
-- ⏳ **Phase 5**: Release Command Implementation (pending)
+- ✅ **Phase 5**: Release Command Integration (commit: TBD)
+
+  - **FIXED**: Moved Prometheus template rendering from docker-compose step to independent step in release handler
+  - Created `RenderPrometheusTemplatesStep` to render Prometheus templates
+  - Added `render_prometheus_templates()` method to `ReleaseCommandHandler`
+  - Prometheus templates now rendered independently at Step 5 (after tracker templates, before docker-compose)
+  - Docker Compose step only adds Prometheus config to context (no template rendering)
+  - Added `RenderPrometheusTemplates` variant to `ReleaseStep` enum
+  - Extended `EnvironmentTestBuilder` with `with_prometheus_config()` method
+  - All linters passing, all tests passing (1507 tests)
+  - **Architectural Principle**: Each service renders its templates independently in the release handler
+
+- ⏳ **Phase 6**: Ansible Deployment (pending)
 - ⏳ **Phase 6**: Ansible Playbook Integration (pending)
 - ⏳ **Phase 7**: Testing (pending)
 - ⏳ **Phase 8**: Documentation (pending)
@@ -85,9 +97,27 @@ This task adds Prometheus as a metrics collection service for the Torrust Tracke
 - [ ] Prometheus depends on tracker service (starts after tracker container starts, no health check)
 - [ ] Metrics API token and port read from tracker HTTP API configuration (`tracker.http_api.admin_token` and `tracker.http_api.bind_address`)
 - [ ] Prometheus configuration is dynamic (uses Tera templating)
+- [x] **Independent Template Rendering**: Each service renders its templates independently in the release handler
+  - Prometheus templates rendered by dedicated `RenderPrometheusTemplatesStep` in release handler
+  - Tracker templates rendered by dedicated `RenderTrackerTemplatesStep` in release handler
+  - Docker Compose templates rendered by dedicated `RenderDockerComposeTemplatesStep` in release handler
+  - **Rationale**: Docker Compose templates are NOT the "master" templates - they only define service orchestration
+  - **Source of Truth**: The environment configuration determines which services are enabled
+  - **Example**: MySQL service has docker-compose configuration but no separate config files (service-specific)
 
 ### Anti-Patterns to Avoid
 
+- ❌ Making Prometheus mandatory for all deployments
+- ❌ Hardcoding API tokens in templates
+- ❌ Starting Prometheus before tracker is ready
+- ❌ Duplicating tracker endpoint configuration
+- ❌ Mixing metrics collection logic with other services
+- ❌ **Rendering service templates from within docker-compose template rendering** (CRITICAL)
+
+  - Docker Compose step should ONLY render docker-compose files
+  - Each service's templates should be rendered independently in the release handler
+  - The handler orchestrates all template rendering steps based on environment config
+
 - ❌ Making Prometheus mandatory for all deployments
 - ❌ Hardcoding API tokens in templates
 - ❌ Starting Prometheus before tracker is ready

src/application/command_handlers/release/handler.rs

@@ -11,7 +11,7 @@ use crate::adapters::ansible::AnsibleClient;
 use crate::application::command_handlers::common::StepResult;
 use crate::application::steps::{
     application::{CreateTrackerStorageStep, DeployTrackerConfigStep, InitTrackerDatabaseStep},
-    rendering::RenderTrackerTemplatesStep,
+    rendering::{RenderPrometheusTemplatesStep, RenderTrackerTemplatesStep},
     DeployComposeFilesStep, RenderDockerComposeTemplatesStep,
 };
 use crate::domain::environment::repository::{EnvironmentRepository, TypedEnvironmentRepository};
@@ -199,10 +199,13 @@ impl ReleaseCommandHandler {
         // Step 4: Deploy tracker configuration to remote
         self.deploy_tracker_config_to_remote(environment, &tracker_build_dir, instance_ip)?;
 
-        // Step 5: Render Docker Compose templates
+        // Step 5: Render Prometheus configuration templates (if enabled)
+        Self::render_prometheus_templates(environment)?;
+
+        // Step 6: Render Docker Compose templates
         let compose_build_dir = self.render_docker_compose_templates(environment).await?;
 
-        // Step 6: Deploy compose files to remote
+        // Step 7: Deploy compose files to remote
         self.deploy_compose_files_to_remote(environment, &compose_build_dir, instance_ip)?;
 
         let released = environment.clone().released();
@@ -308,6 +311,54 @@ impl ReleaseCommandHandler {
         Ok(tracker_build_dir)
     }
 
+    /// Render Prometheus configuration templates to the build directory (if enabled)
+    ///
+    /// This step is optional and only executes if Prometheus is configured in the environment.
+    /// If Prometheus is not configured, the step is skipped without error.
+    ///
+    /// # Errors
+    ///
+    /// Returns a tuple of (error, `ReleaseStep::RenderPrometheusTemplates`) if rendering fails
+    #[allow(clippy::result_large_err)]
+    fn render_prometheus_templates(
+        environment: &Environment<Releasing>,
+    ) -> StepResult<(), ReleaseCommandHandlerError, ReleaseStep> {
+        let current_step = ReleaseStep::RenderPrometheusTemplates;
+
+        // Check if Prometheus is configured
+        if environment.context().user_inputs.prometheus.is_none() {
+            info!(
+                command = "release",
+                step = %current_step,
+                status = "skipped",
+                "Prometheus not configured - skipping template rendering"
+            );
+            return Ok(());
+        }
+
+        let template_manager = Arc::new(TemplateManager::new(environment.templates_dir()));
+        let step = RenderPrometheusTemplatesStep::new(
+            Arc::new(environment.clone()),
+            template_manager,
+            environment.build_dir().clone(),
+        );
+
+        step.execute().map_err(|e| {
+            (
+                ReleaseCommandHandlerError::TemplateRendering(e.to_string()),
+                current_step,
+            )
+        })?;
+
+        info!(
+            command = "release",
+            step = %current_step,
+            "Prometheus configuration templates rendered successfully"
+        );
+
+        Ok(())
+    }
+
     /// Deploy tracker configuration to the remote host via Ansible
     ///
     /// # Arguments

src/application/steps/rendering/docker_compose_templates.rs

@@ -152,7 +152,7 @@ impl<S> RenderDockerComposeTemplatesStep<S> {
 
         // Create contexts based on database configuration
         let database_config = &self.environment.context().user_inputs.tracker.core.database;
-        let (env_context, docker_compose_context) = match database_config {
+        let (env_context, mut docker_compose_context) = match database_config {
             DatabaseConfig::Sqlite { .. } => {
                 let env_context = EnvContext::new(admin_token);
                 let docker_compose_context = DockerComposeContext::new_sqlite(ports);
@@ -189,6 +189,12 @@ impl<S> RenderDockerComposeTemplatesStep<S> {
             }
         };
 
+        // Add Prometheus configuration if present
+        if let Some(prometheus_config) = &self.environment.context().user_inputs.prometheus {
+            docker_compose_context =
+                docker_compose_context.with_prometheus(prometheus_config.clone());
+        }
+
         let compose_build_dir = generator
             .render(&env_context, &docker_compose_context)
             .await?;

src/application/steps/rendering/mod.rs

@@ -10,6 +10,7 @@
 //! - `opentofu_templates` - `OpenTofu` template rendering for infrastructure
 //! - `docker_compose_templates` - Docker Compose template rendering for deployment
 //! - `tracker_templates` - Tracker configuration template rendering
+//! - `prometheus_templates` - Prometheus configuration template rendering
 //!
 //! ## Key Features
 //!
@@ -24,9 +25,11 @@
 pub mod ansible_templates;
 pub mod docker_compose_templates;
 pub mod opentofu_templates;
+pub mod prometheus_templates;
 pub mod tracker_templates;
 
 pub use ansible_templates::RenderAnsibleTemplatesStep;
 pub use docker_compose_templates::RenderDockerComposeTemplatesStep;
 pub use opentofu_templates::RenderOpenTofuTemplatesStep;
+pub use prometheus_templates::RenderPrometheusTemplatesStep;
 pub use tracker_templates::RenderTrackerTemplatesStep;