enabledEnvironments = new ArrayList<>();
+
+ /**
+ * Description of what this feature does
+ */
+ private String description;
+
+ /**
+ * When this feature was last modified
+ */
+ private String lastModified;
+
+ /**
+ * Check if a specific user should have this feature enabled.
+ *
+ * Uses consistent hashing to determine if user is in rollout percentage.
+ * Same user will always get the same result for a given percentage.
+ *
+ * @param userId The user ID to check
+ * @return true if feature should be enabled for this user
+ */
+ public boolean isEnabledForUser(String userId) {
+ if (!enabled) {
+ return false;
+ }
+
+ // Explicitly enabled users always get the feature
+ if (enabledUsers.contains(userId)) {
+ return true;
+ }
+
+ // If rollout is 100%, everyone gets it
+ if (rolloutPercentage >= 100) {
+ return true;
+ }
+
+ // If rollout is 0%, nobody gets it (except explicit users)
+ if (rolloutPercentage <= 0) {
+ return false;
+ }
+
+ // Use consistent hashing to determine if user is in rollout percentage
+ int hash = Math.abs(userId.hashCode());
+ return (hash % 100) < rolloutPercentage;
+ }
+
+ /**
+ * Check if feature is enabled for a specific environment
+ *
+ * @param environment The environment to check (dev, stage, prod, etc.)
+ * @return true if feature is enabled for this environment
+ */
+ public boolean isEnabledForEnvironment(String environment) {
+ if (!enabled) {
+ return false;
+ }
+
+ // If no environments specified, enabled for all
+ if (enabledEnvironments.isEmpty()) {
+ return true;
+ }
+
+ return enabledEnvironments.contains(environment);
+ }
+
+ /**
+ * Create a disabled feature toggle
+ */
+ public static FeatureToggle disabled() {
+ FeatureToggle toggle = new FeatureToggle();
+ toggle.setEnabled(false);
+ return toggle;
+ }
+
+ /**
+ * Create a fully enabled feature toggle
+ */
+ public static FeatureToggle fullyEnabled() {
+ FeatureToggle toggle = new FeatureToggle();
+ toggle.setEnabled(true);
+ toggle.setRolloutPercentage(100);
+ return toggle;
+ }
+
+ /**
+ * Create a feature toggle with specific rollout percentage
+ */
+ public static FeatureToggle withRollout(int percentage) {
+ FeatureToggle toggle = new FeatureToggle();
+ toggle.setEnabled(true);
+ toggle.setRolloutPercentage(Math.max(0, Math.min(100, percentage)));
+ return toggle;
+ }
+}
diff --git a/order-service/src/main/java/com/selimhorri/app/config/FeatureToggleService.java b/order-service/src/main/java/com/selimhorri/app/config/FeatureToggleService.java
new file mode 100644
index 000000000..43b8bb35a
--- /dev/null
+++ b/order-service/src/main/java/com/selimhorri/app/config/FeatureToggleService.java
@@ -0,0 +1,226 @@
+package com.selimhorri.app.config;
+
+import lombok.Data;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.cloud.context.config.annotation.RefreshScope;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.PostConstruct;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Service for managing feature toggles (feature flags).
+ *
+ * Feature toggles allow features to be enabled/disabled dynamically without
+ * redeployment, enabling:
+ * - Gradual rollouts (canary releases)
+ * - A/B testing
+ * - Kill switches for problematic features
+ * - Environment-specific features
+ *
+ * Configuration is externalized in application.yml and can be refreshed
+ * dynamically using Spring Cloud Config refresh endpoint.
+ *
+ * Usage example:
+ *
+ *
+ * if (featureToggleService.isEnabled("new-checkout-flow")) {
+ * return newCheckoutFlow();
+ * } else {
+ * return legacyCheckoutFlow();
+ * }
+ *
+ *
+ * @author ecommerce-team
+ * @version 1.0
+ */
+@Service
+@ConfigurationProperties(prefix = "features")
+@RefreshScope
+@Data
+@Slf4j
+public class FeatureToggleService {
+
+ /**
+ * Map of feature name to feature toggle configuration
+ */
+ private Map toggles = new HashMap<>();
+
+ /**
+ * Current environment (dev, stage, prod)
+ */
+ private String environment = "dev";
+
+ @PostConstruct
+ public void init() {
+ log.info("Feature Toggle Service initialized with {} features", toggles.size());
+ toggles.forEach((name, toggle) -> {
+ log.info("Feature '{}': enabled={}, rollout={}%",
+ name, toggle.isEnabled(), toggle.getRolloutPercentage());
+ });
+ }
+
+ /**
+ * Check if a feature is enabled globally.
+ *
+ * @param featureName The name of the feature
+ * @return true if feature is enabled
+ */
+ public boolean isEnabled(String featureName) {
+ FeatureToggle toggle = toggles.get(featureName);
+
+ if (toggle == null) {
+ log.warn("Feature toggle '{}' not found. Returning false by default.", featureName);
+ return false;
+ }
+
+ boolean enabledForEnv = toggle.isEnabledForEnvironment(environment);
+ boolean globallyEnabled = toggle.isEnabled();
+
+ log.debug("Feature '{}' check: globallyEnabled={}, enabledForEnv={}",
+ featureName, globallyEnabled, enabledForEnv);
+
+ return globallyEnabled && enabledForEnv;
+ }
+
+ /**
+ * Check if a feature is enabled for a specific user.
+ *
+ * Takes into account:
+ * - Global enabled flag
+ * - Environment enablement
+ * - User-specific enablement
+ * - Rollout percentage (consistent hashing)
+ *
+ * @param featureName The name of the feature
+ * @param userId The user ID to check
+ * @return true if feature is enabled for this user
+ */
+ public boolean isEnabledForUser(String featureName, String userId) {
+ FeatureToggle toggle = toggles.get(featureName);
+
+ if (toggle == null) {
+ log.warn("Feature toggle '{}' not found for user {}. Returning false.", featureName, userId);
+ return false;
+ }
+
+ if (!toggle.isEnabledForEnvironment(environment)) {
+ log.debug("Feature '{}' not enabled for environment '{}'", featureName, environment);
+ return false;
+ }
+
+ boolean enabledForUser = toggle.isEnabledForUser(userId);
+
+ log.debug("Feature '{}' check for user {}: enabled={}", featureName, userId, enabledForUser);
+
+ return enabledForUser;
+ }
+
+ /**
+ * Get all feature toggles and their current state
+ *
+ * @return Map of all feature toggles
+ */
+ public Map getAllToggles() {
+ return new HashMap<>(toggles);
+ }
+
+ /**
+ * Update a feature toggle at runtime.
+ *
+ * Note: This only updates the in-memory state. For persistent changes,
+ * update the configuration source (application.yml or Config Server).
+ *
+ * @param featureName Name of the feature
+ * @param toggle New toggle configuration
+ */
+ public void updateToggle(String featureName, FeatureToggle toggle) {
+ log.info("Updating feature toggle '{}': enabled={}, rollout={}%",
+ featureName, toggle.isEnabled(), toggle.getRolloutPercentage());
+
+ toggle.setLastModified(LocalDateTime.now().format(DateTimeFormatter.ISO_DATE_TIME));
+ toggles.put(featureName, toggle);
+ }
+
+ /**
+ * Enable a feature for all users
+ *
+ * @param featureName Name of the feature
+ */
+ public void enableFeature(String featureName) {
+ FeatureToggle toggle = toggles.getOrDefault(featureName, new FeatureToggle());
+ toggle.setEnabled(true);
+ toggle.setRolloutPercentage(100);
+ updateToggle(featureName, toggle);
+ }
+
+ /**
+ * Disable a feature for all users
+ *
+ * @param featureName Name of the feature
+ */
+ public void disableFeature(String featureName) {
+ FeatureToggle toggle = toggles.getOrDefault(featureName, new FeatureToggle());
+ toggle.setEnabled(false);
+ updateToggle(featureName, toggle);
+ }
+
+ /**
+ * Set rollout percentage for gradual release
+ *
+ * @param featureName Name of the feature
+ * @param percentage Percentage of users (0-100)
+ */
+ public void setRolloutPercentage(String featureName, int percentage) {
+ if (percentage < 0 || percentage > 100) {
+ throw new IllegalArgumentException("Percentage must be between 0 and 100");
+ }
+
+ FeatureToggle toggle = toggles.getOrDefault(featureName, new FeatureToggle());
+ toggle.setEnabled(true);
+ toggle.setRolloutPercentage(percentage);
+ updateToggle(featureName, toggle);
+
+ log.info("Feature '{}' rollout set to {}%", featureName, percentage);
+ }
+
+ /**
+ * Get the current rollout percentage for a feature
+ *
+ * @param featureName Name of the feature
+ * @return Rollout percentage (0-100), or 0 if feature doesn't exist
+ */
+ public int getRolloutPercentage(String featureName) {
+ FeatureToggle toggle = toggles.get(featureName);
+ return toggle != null ? toggle.getRolloutPercentage() : 0;
+ }
+
+ /**
+ * Add a user to the explicit enable list for a feature
+ *
+ * @param featureName Name of the feature
+ * @param userId User ID to enable
+ */
+ public void enableForUser(String featureName, String userId) {
+ FeatureToggle toggle = toggles.getOrDefault(featureName, new FeatureToggle());
+ if (!toggle.getEnabledUsers().contains(userId)) {
+ toggle.getEnabledUsers().add(userId);
+ updateToggle(featureName, toggle);
+ log.info("Feature '{}' explicitly enabled for user: {}", featureName, userId);
+ }
+ }
+
+ /**
+ * Check if a feature exists in configuration
+ *
+ * @param featureName Name of the feature
+ * @return true if feature exists
+ */
+ public boolean featureExists(String featureName) {
+ return toggles.containsKey(featureName);
+ }
+}
diff --git a/order-service/src/main/java/com/selimhorri/app/config/ResilienceEventListener.java b/order-service/src/main/java/com/selimhorri/app/config/ResilienceEventListener.java
new file mode 100644
index 000000000..cdf9f0fbd
--- /dev/null
+++ b/order-service/src/main/java/com/selimhorri/app/config/ResilienceEventListener.java
@@ -0,0 +1,185 @@
+package com.selimhorri.app.config;
+
+import io.github.resilience4j.bulkhead.event.BulkheadEvent;
+import io.github.resilience4j.bulkhead.event.BulkheadOnCallFinishedEvent;
+import io.github.resilience4j.bulkhead.event.BulkheadOnCallPermittedEvent;
+import io.github.resilience4j.bulkhead.event.BulkheadOnCallRejectedEvent;
+import io.github.resilience4j.circuitbreaker.event.*;
+import io.github.resilience4j.retry.event.*;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.context.event.EventListener;
+import org.springframework.stereotype.Component;
+
+/**
+ * Event listeners for Resilience4j patterns.
+ *
+ * Provides centralized logging and monitoring for:
+ * - Circuit Breaker events
+ * - Bulkhead events
+ * - Retry events
+ *
+ * These events are useful for:
+ * - Debugging resilience issues
+ * - Monitoring system health
+ * - Alerting on pattern activations
+ * - Metrics collection
+ *
+ * @author ecommerce-team
+ * @version 1.0
+ */
+@Component
+@Slf4j
+public class ResilienceEventListener {
+
+ // ========================================
+ // Circuit Breaker Events
+ // ========================================
+
+ @EventListener
+ public void onCircuitBreakerStateTransition(CircuitBreakerOnStateTransitionEvent event) {
+ log.warn("Circuit Breaker '{}' transitioned from {} to {}",
+ event.getCircuitBreakerName(),
+ event.getStateTransition().getFromState(),
+ event.getStateTransition().getToState());
+
+ // In production, you might:
+ // - Send alert if circuit opens
+ // - Update dashboard
+ // - Trigger auto-scaling if needed
+ }
+
+ @EventListener
+ public void onCircuitBreakerError(CircuitBreakerOnErrorEvent event) {
+ log.error("Circuit Breaker '{}' recorded error: {}",
+ event.getCircuitBreakerName(),
+ event.getThrowable().getMessage());
+ }
+
+ @EventListener
+ public void onCircuitBreakerSuccess(CircuitBreakerOnSuccessEvent event) {
+ log.debug("Circuit Breaker '{}' recorded success. Duration: {}ms",
+ event.getCircuitBreakerName(),
+ event.getElapsedDuration().toMillis());
+ }
+
+ @EventListener
+ public void onCircuitBreakerCallNotPermitted(CircuitBreakerOnCallNotPermittedEvent event) {
+ log.warn("Circuit Breaker '{}' call not permitted - circuit is OPEN",
+ event.getCircuitBreakerName());
+
+ // Alert! Service is completely blocked
+ // Consider scaling, failover, or manual intervention
+ }
+
+ // ========================================
+ // Bulkhead Events
+ // ========================================
+
+ @EventListener
+ public void onBulkheadCallRejected(BulkheadOnCallRejectedEvent event) {
+ log.warn("Bulkhead '{}' rejected call - max concurrent calls reached",
+ event.getBulkheadName());
+
+ // This indicates system is at capacity
+ // Consider:
+ // - Auto-scaling
+ // - Load shedding
+ // - Alerting operations team
+ }
+
+ @EventListener
+ public void onBulkheadCallPermitted(BulkheadOnCallPermittedEvent event) {
+ log.debug("Bulkhead '{}' permitted call",
+ event.getBulkheadName());
+ }
+
+ @EventListener
+ public void onBulkheadCallFinished(BulkheadOnCallFinishedEvent event) {
+ log.debug("Bulkhead '{}' call finished",
+ event.getBulkheadName());
+ }
+
+ // ========================================
+ // Retry Events
+ // ========================================
+
+ @EventListener
+ public void onRetryAttempt(RetryOnRetryEvent event) {
+ log.warn("Retry attempt {} for '{}'. Last exception: {}",
+ event.getNumberOfRetryAttempts(),
+ event.getName(),
+ event.getLastThrowable().getMessage());
+
+ // Track retry metrics
+ // If too many retries, might indicate systematic issue
+ }
+
+ @EventListener
+ public void onRetrySuccess(RetryOnSuccessEvent event) {
+ log.info("Retry succeeded for '{}' after {} attempts",
+ event.getName(),
+ event.getNumberOfRetryAttempts());
+
+ // Good to know - service recovered
+ // But many retries might indicate unstable dependency
+ }
+
+ @EventListener
+ public void onRetryError(RetryOnErrorEvent event) {
+ log.error("Retry failed for '{}' after {} attempts. Final error: {}",
+ event.getName(),
+ event.getNumberOfRetryAttempts(),
+ event.getLastThrowable().getMessage());
+
+ // All retries exhausted - invoking fallback
+ // Alert operations team
+ // Check dependent service health
+ }
+
+ @EventListener
+ public void onRetryIgnoredError(RetryOnIgnoredErrorEvent event) {
+ log.info("Retry ignored error for '{}': {}",
+ event.getName(),
+ event.getLastThrowable().getMessage());
+
+ // Error type is configured to not trigger retry
+ // This is expected for certain error types
+ }
+
+ /**
+ * Generic handler for any Bulkhead event
+ * Use for custom metrics collection
+ */
+ @EventListener
+ public void onBulkheadEvent(BulkheadEvent event) {
+ // Custom metrics collection
+ // Example: Send to Prometheus, Datadog, etc.
+ log.trace("Bulkhead event: {} - {}",
+ event.getBulkheadName(),
+ event.getEventType());
+ }
+
+ /**
+ * Generic handler for any Circuit Breaker event
+ * Use for custom metrics collection
+ */
+ @EventListener
+ public void onCircuitBreakerEvent(CircuitBreakerEvent event) {
+ // Custom metrics collection
+ log.trace("Circuit Breaker event: {} - {}",
+ event.getCircuitBreakerName(),
+ event.getEventType());
+ }
+
+ /**
+ * Generic handler for any Retry event
+ * Use for custom metrics collection
+ */
+ @EventListener
+ public void onRetryEvent(RetryEvent event) {
+ // Custom metrics collection
+ log.trace("Retry event: {} - {}",
+ event.getName(),
+ event.getEventType());
+ }
+}
diff --git a/order-service/src/main/java/com/selimhorri/app/health/DatabaseHealthIndicator.java b/order-service/src/main/java/com/selimhorri/app/health/DatabaseHealthIndicator.java
new file mode 100644
index 000000000..261ec76e2
--- /dev/null
+++ b/order-service/src/main/java/com/selimhorri/app/health/DatabaseHealthIndicator.java
@@ -0,0 +1,53 @@
+package com.selimhorri.app.health;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.boot.actuate.health.Health;
+import org.springframework.boot.actuate.health.HealthIndicator;
+import org.springframework.stereotype.Component;
+
+import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.Statement;
+
+/**
+ * Custom health indicator for database connectivity
+ */
+@Component("database")
+@RequiredArgsConstructor
+@Slf4j
+public class DatabaseHealthIndicator implements HealthIndicator {
+
+ private final DataSource dataSource;
+
+ @Override
+ public Health health() {
+ try (Connection connection = dataSource.getConnection();
+ Statement statement = connection.createStatement();
+ ResultSet resultSet = statement.executeQuery("SELECT 1")) {
+
+ if (resultSet.next()) {
+ // Get database metadata
+ String databaseProductName = connection.getMetaData().getDatabaseProductName();
+ String databaseProductVersion = connection.getMetaData().getDatabaseProductVersion();
+
+ return Health.up()
+ .withDetail("database", databaseProductName)
+ .withDetail("version", databaseProductVersion)
+ .withDetail("status", "Connected")
+ .build();
+ } else {
+ return Health.down()
+ .withDetail("status", "Unable to validate connection")
+ .build();
+ }
+ } catch (Exception e) {
+ log.error("Database health check failed", e);
+ return Health.down()
+ .withDetail("error", e.getMessage())
+ .withException(e)
+ .build();
+ }
+ }
+}
diff --git a/order-service/src/main/java/com/selimhorri/app/resilience/OrderBulkheadService.java b/order-service/src/main/java/com/selimhorri/app/resilience/OrderBulkheadService.java
new file mode 100644
index 000000000..ff8327887
--- /dev/null
+++ b/order-service/src/main/java/com/selimhorri/app/resilience/OrderBulkheadService.java
@@ -0,0 +1,174 @@
+package com.selimhorri.app.resilience;
+
+import com.selimhorri.app.dto.OrderDto;
+import com.selimhorri.app.service.OrderService;
+import io.github.resilience4j.bulkhead.annotation.Bulkhead;
+import io.github.resilience4j.bulkhead.annotation.Bulkhead.Type;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+/**
+ * Service implementing the Bulkhead Pattern for order processing.
+ *
+ * The Bulkhead pattern isolates resources for different types of operations,
+ * preventing one type of workload from consuming all available resources
+ * and affecting other operations.
+ *
+ * This implementation provides:
+ * - Semaphore-based bulkh AAAºead for synchronous order processing
+ * - Thread pool-based bulkhead for asynchronous order processing
+ * - Fallback mechanisms when bulkhead is full
+ * - Metrics and monitoring through Resilience4j
+ *
+ * @author ecommerce-team
+ * @version 1.0
+ */
+@Service
+@Slf4j
+@RequiredArgsConstructor
+public class OrderBulkheadService {
+
+ private final OrderService orderService;
+
+ /**
+ * Process order with semaphore-based bulkhead protection.
+ *
+ * This limits concurrent order processing to prevent resource exhaustion.
+ * When the limit is reached, the fallback method is called.
+ *
+ * @param orderDto The order to process
+ * @return Processed order
+ */
+ @Bulkhead(name = "orderProcessing", fallbackMethod = "orderProcessingFallback", type = Type.SEMAPHORE)
+ public OrderDto processOrder(OrderDto orderDto) {
+ log.info("Processing order with bulkhead protection: {}", orderDto.getOrderId());
+
+ try {
+ // Simulate processing time
+ Thread.sleep(100);
+
+ // Actual order processing
+ OrderDto savedOrder = orderService.save(orderDto);
+
+ log.info("Successfully processed order: {}", savedOrder.getOrderId());
+ return savedOrder;
+
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.error("Order processing interrupted: {}", orderDto.getOrderId());
+ throw new RuntimeException("Order processing interrupted", e);
+ }
+ }
+
+ /**
+ * Fallback method when bulkhead is full.
+ *
+ * This provides graceful degradation by queueing the order
+ * for later processing instead of rejecting it outright.
+ *
+ * @param orderDto The order that couldn't be processed
+ * @param exception The exception that triggered the fallback
+ * @return Order with pending status
+ */
+ public OrderDto orderProcessingFallback(OrderDto orderDto, Exception exception) {
+ log.error("Bulkhead full for order processing. Order queued for retry: {}. Reason: {}",
+ orderDto.getOrderId(),
+ exception.getMessage());
+
+ // Set order description to indicate pending retry status
+ orderDto.setOrderDesc("PENDING_RETRY: " + orderDto.getOrderDesc());
+
+ // In a real implementation, you would:
+ // 1. Queue to message broker (RabbitMQ, Kafka)
+ // 2. Store in retry queue database
+ // 3. Schedule for later processing
+
+ return orderDto;
+ }
+
+ /**
+ * Process order asynchronously with thread pool bulkhead.
+ *
+ * This uses a dedicated thread pool for async processing,
+ * preventing blocking operations from affecting the main thread pool.
+ *
+ * @param orderDto The order to process
+ * @return Processed order
+ */
+ @Bulkhead(name = "orderAsyncProcessing", fallbackMethod = "orderAsyncProcessingFallback", type = Type.THREADPOOL)
+ public OrderDto processOrderAsync(OrderDto orderDto) {
+ log.info("Processing order asynchronously with thread pool bulkhead: {}", orderDto.getOrderId());
+
+ try {
+ // Simulate async processing
+ Thread.sleep(200);
+
+ OrderDto savedOrder = orderService.save(orderDto);
+
+ log.info("Successfully processed order async: {}", savedOrder.getOrderId());
+ return savedOrder;
+
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.error("Async order processing interrupted: {}", orderDto.getOrderId());
+ throw new RuntimeException("Async order processing interrupted", e);
+ }
+ }
+
+ /**
+ * Fallback for async processing when thread pool is full.
+ *
+ * @param orderDto The order that couldn't be processed
+ * @param exception The exception that triggered the fallback
+ * @return Order with queued status
+ */
+ public OrderDto orderAsyncProcessingFallback(OrderDto orderDto, Exception exception) {
+ log.error("Thread pool bulkhead full for async order processing. Order queued: {}. Reason: {}",
+ orderDto.getOrderId(),
+ exception.getMessage());
+
+ orderDto.setOrderDesc("QUEUED_FOR_ASYNC: " + orderDto.getOrderDesc());
+
+ return orderDto;
+ }
+
+ /**
+ * High priority order processing with dedicated bulkhead.
+ *
+ * This ensures that high-priority orders have dedicated resources
+ * and are not affected by regular order processing load.
+ *
+ * @param orderDto High priority order
+ * @return Processed order
+ */
+ @Bulkhead(name = "highPriorityOrders", fallbackMethod = "highPriorityFallback", type = Type.SEMAPHORE)
+ public OrderDto processHighPriorityOrder(OrderDto orderDto) {
+ log.info("Processing HIGH PRIORITY order: {}", orderDto.getOrderId());
+
+ // Fast-track processing for high priority orders
+ // In a real implementation, you would add a priority field to OrderDto
+ orderDto.setOrderDesc("HIGH_PRIORITY: " + orderDto.getOrderDesc());
+ OrderDto savedOrder = orderService.save(orderDto);
+
+ return savedOrder;
+ }
+
+ /**
+ * Fallback for high priority orders.
+ * High priority orders should rarely hit this, but when they do,
+ * we need to handle them specially.
+ */
+ public OrderDto highPriorityFallback(OrderDto orderDto, Exception exception) {
+ log.error("CRITICAL: High priority order bulkhead full: {}. Immediate escalation needed!",
+ orderDto.getOrderId());
+
+ // In production:
+ // 1. Alert operations team
+ // 2. Auto-scale if in cloud
+ // 3. Queue to highest priority queue
+
+ orderDto.setOrderDesc("ESCALATED: " + orderDto.getOrderDesc());
+ return orderDto;
+ }
+}
diff --git a/order-service/src/main/java/com/selimhorri/app/resilience/OrderRetryService.java b/order-service/src/main/java/com/selimhorri/app/resilience/OrderRetryService.java
new file mode 100644
index 000000000..84a9c80fd
--- /dev/null
+++ b/order-service/src/main/java/com/selimhorri/app/resilience/OrderRetryService.java
@@ -0,0 +1,194 @@
+package com.selimhorri.app.resilience;
+
+import com.selimhorri.app.dto.OrderDto;
+import com.selimhorri.app.service.OrderService;
+import io.github.resilience4j.retry.annotation.Retry;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.web.client.RestTemplate;
+
+/**
+ * Service implementing the Retry Pattern with exponential backoff.
+ *
+ * The Retry pattern automatically retries failed operations with
+ * increasing delays between attempts (exponential backoff).
+ *
+ * This is particularly useful for:
+ * - Transient network failures
+ * - Temporary service unavailability
+ * - Database connection timeouts
+ * - External API rate limiting
+ *
+ * Benefits:
+ * - Automatic recovery from transient failures
+ * - Exponential backoff prevents overwhelming struggling services
+ * - Configurable retry logic per operation type
+ * - Fallback mechanisms for ultimate failure
+ *
+ * @author ecommerce-team
+ * @version 1.0
+ */
+@Service
+@Slf4j
+@RequiredArgsConstructor
+public class OrderRetryService {
+
+ private final OrderService orderService;
+ private final RestTemplate restTemplate;
+
+ /**
+ * Save order with retry on database failures.
+ *
+ * Retries up to 3 times with exponential backoff if database operations fail.
+ * Useful for handling transient DB connection issues.
+ *
+ * @param orderDto Order to save
+ * @return Saved order
+ */
+ @Retry(name = "orderProcessing", fallbackMethod = "saveOrderFallback")
+ public OrderDto saveOrderWithRetry(OrderDto orderDto) {
+ log.info("Attempting to save order with retry: {}", orderDto.getOrderId());
+
+ OrderDto savedOrder = orderService.save(orderDto);
+
+ log.info("Successfully saved order: {}", savedOrder.getOrderId());
+ return savedOrder;
+ }
+
+ /**
+ * Fallback method when all retry attempts fail.
+ * Stores order in a dead-letter queue for manual processing.
+ *
+ * @param orderDto The order that failed to save
+ * @param exception The exception that caused the failure
+ * @return Order with error status
+ */
+ public OrderDto saveOrderFallback(OrderDto orderDto, Exception exception) {
+ log.error("All retry attempts failed for order: {}. Error: {}",
+ orderDto.getOrderId(),
+ exception.getMessage());
+
+ // In production, you would:
+ // 1. Store in dead-letter queue (DLQ)
+ // 2. Send alert to operations team
+ // 3. Log to error tracking system (Sentry, Rollbar, etc.)
+
+ orderDto.setOrderDesc("FAILED: " + orderDto.getOrderDesc());
+
+ return orderDto;
+ }
+
+ /**
+ * Call external API with retry logic.
+ *
+ * Retries up to 5 times with exponential backoff for external API calls.
+ * More retry attempts because external APIs are more prone to transient issues.
+ *
+ * @param apiUrl API endpoint URL
+ * @param orderId Order ID for the API call
+ * @return API response
+ */
+ @Retry(name = "externalApiCall", fallbackMethod = "externalApiCallFallback")
+ public String callExternalApiWithRetry(String apiUrl, Integer orderId) {
+ log.info("Calling external API with retry: {} for order: {}", apiUrl, orderId);
+
+ try {
+ String response = restTemplate.getForObject(apiUrl + "/" + orderId, String.class);
+ log.info("External API call successful for order: {}", orderId);
+ return response;
+
+ } catch (Exception e) {
+ log.warn("External API call failed (will retry): {} - {}", apiUrl, e.getMessage());
+ throw e;
+ }
+ }
+
+ /**
+ * Fallback for external API calls.
+ * Returns cached data or default response.
+ *
+ * @param apiUrl The API URL that failed
+ * @param orderId The order ID
+ * @param exception The exception thrown
+ * @return Fallback response
+ */
+ public String externalApiCallFallback(String apiUrl, Integer orderId, Exception exception) {
+ log.error("External API call failed after all retries: {} for order: {}. Error: {}",
+ apiUrl, orderId, exception.getMessage());
+
+ // Return cached data or default response
+ return "{\"status\":\"unavailable\",\"orderId\":" + orderId
+ + ",\"message\":\"Service temporarily unavailable\"}";
+ }
+
+ /**
+ * Process payment with retry.
+ * Critical operation that needs multiple retry attempts.
+ *
+ * @param orderId Order ID for payment
+ * @param amount Amount to charge
+ * @return Payment confirmation
+ */
+ @Retry(name = "orderProcessing", fallbackMethod = "processPaymentFallback")
+ public String processPaymentWithRetry(Integer orderId, Double amount) {
+ log.info("Processing payment with retry for order: {}, amount: {}", orderId, amount);
+
+ // Simulate payment processing that might fail
+ if (Math.random() < 0.3) { // 30% chance of transient failure
+ throw new RuntimeException("Payment gateway temporarily unavailable");
+ }
+
+ log.info("Payment processed successfully for order: {}", orderId);
+ return "PAYMENT_SUCCESS";
+ }
+
+ /**
+ * Fallback for payment processing.
+ * Queues payment for later retry or manual processing.
+ */
+ public String processPaymentFallback(Integer orderId, Double amount, Exception exception) {
+ log.error("Payment processing failed after retries for order: {}. Queuing for manual review.", orderId);
+
+ // In production:
+ // 1. Queue to payment retry service
+ // 2. Alert finance team
+ // 3. Update order status to PAYMENT_PENDING
+
+ return "PAYMENT_QUEUED_FOR_RETRY";
+ }
+
+ /**
+ * Update inventory with retry.
+ * Ensures inventory updates don't fail due to transient issues.
+ *
+ * @param productId Product ID
+ * @param quantity Quantity to update
+ * @return Update status
+ */
+ @Retry(name = "orderProcessing", fallbackMethod = "updateInventoryFallback")
+ public boolean updateInventoryWithRetry(Integer productId, Integer quantity) {
+ log.info("Updating inventory with retry - Product: {}, Quantity: {}", productId, quantity);
+
+ // Simulate inventory update that might have transient failures
+ if (Math.random() < 0.2) { // 20% chance of failure
+ throw new RuntimeException("Inventory service connection timeout");
+ }
+
+ log.info("Inventory updated successfully for product: {}", productId);
+ return true;
+ }
+
+ /**
+ * Fallback for inventory update.
+ * Queues update for eventual consistency.
+ */
+ public boolean updateInventoryFallback(Integer productId, Integer quantity, Exception exception) {
+ log.error("Inventory update failed after retries for product: {}. Queuing for async update.", productId);
+
+ // Queue for async processing to maintain eventual consistency
+ // In production: send to message queue for later processing
+
+ return false;
+ }
+}
diff --git a/order-service/src/main/java/com/selimhorri/app/resource/FeatureToggleController.java b/order-service/src/main/java/com/selimhorri/app/resource/FeatureToggleController.java
new file mode 100644
index 000000000..741b85344
--- /dev/null
+++ b/order-service/src/main/java/com/selimhorri/app/resource/FeatureToggleController.java
@@ -0,0 +1,196 @@
+package com.selimhorri.app.resource;
+
+import com.selimhorri.app.config.FeatureToggle;
+import com.selimhorri.app.config.FeatureToggleService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * REST Controller for managing feature toggles.
+ *
+ * Provides endpoints to:
+ * - View all feature toggles
+ * - Check if specific feature is enabled
+ * - Enable/disable features
+ * - Update rollout percentage
+ *
+ * This allows operations teams to control feature rollout without redeployment.
+ *
+ * @author ecommerce-team
+ * @version 1.0
+ */
+@RestController
+@RequestMapping("/actuator/features")
+@RequiredArgsConstructor
+@Slf4j
+public class FeatureToggleController {
+
+ private final FeatureToggleService featureToggleService;
+
+ /**
+ * Get all configured feature toggles
+ *
+ * GET /actuator/features
+ *
+ * @return Map of all feature toggles with their configuration
+ */
+ @GetMapping
+ public ResponseEntity> getAllToggles() {
+ log.info("Fetching all feature toggles");
+ return ResponseEntity.ok(featureToggleService.getAllToggles());
+ }
+
+ /**
+ * Get a specific feature toggle
+ *
+ * GET /actuator/features/{featureName}
+ *
+ * @param featureName Name of the feature
+ * @return Feature toggle configuration
+ */
+ @GetMapping("/{featureName}")
+ public ResponseEntity getToggle(@PathVariable String featureName) {
+ log.info("Fetching feature toggle: {}", featureName);
+
+ Map toggles = featureToggleService.getAllToggles();
+ FeatureToggle toggle = toggles.get(featureName);
+
+ if (toggle == null) {
+ return ResponseEntity.notFound().build();
+ }
+
+ return ResponseEntity.ok(toggle);
+ }
+
+ /**
+ * Check if a feature is enabled
+ *
+ * GET /actuator/features/{featureName}/enabled
+ *
+ * @param featureName Name of the feature
+ * @param userId Optional user ID for user-specific check
+ * @return Status indicating if feature is enabled
+ */
+ @GetMapping("/{featureName}/enabled")
+ public ResponseEntity> isFeatureEnabled(
+ @PathVariable String featureName,
+ @RequestParam(required = false) String userId) {
+
+ Map response = new HashMap<>();
+ response.put("feature", featureName);
+
+ if (userId != null) {
+ boolean enabled = featureToggleService.isEnabledForUser(featureName, userId);
+ response.put("enabled", enabled);
+ response.put("userId", userId);
+ log.info("Feature '{}' enabled check for user {}: {}", featureName, userId, enabled);
+ } else {
+ boolean enabled = featureToggleService.isEnabled(featureName);
+ response.put("enabled", enabled);
+ log.info("Feature '{}' enabled check (global): {}", featureName, enabled);
+ }
+
+ return ResponseEntity.ok(response);
+ }
+
+ /**
+ * Update a feature toggle
+ *
+ * PUT /actuator/features/{featureName}
+ *
+ * @param featureName Name of the feature
+ * @param toggle New toggle configuration
+ * @return Updated toggle
+ */
+ @PutMapping("/{featureName}")
+ public ResponseEntity updateToggle(
+ @PathVariable String featureName,
+ @RequestBody FeatureToggle toggle) {
+
+ log.info("Updating feature toggle '{}': enabled={}, rollout={}%",
+ featureName, toggle.isEnabled(), toggle.getRolloutPercentage());
+
+ featureToggleService.updateToggle(featureName, toggle);
+
+ return ResponseEntity.ok(toggle);
+ }
+
+ /**
+ * Enable a feature completely (100% rollout)
+ *
+ * POST /actuator/features/{featureName}/enable
+ *
+ * @param featureName Name of the feature
+ * @return Success message
+ */
+ @PostMapping("/{featureName}/enable")
+ public ResponseEntity> enableFeature(@PathVariable String featureName) {
+ log.info("Enabling feature: {}", featureName);
+
+ featureToggleService.enableFeature(featureName);
+
+ Map response = new HashMap<>();
+ response.put("message", "Feature '" + featureName + "' enabled successfully");
+ response.put("status", "enabled");
+
+ return ResponseEntity.ok(response);
+ }
+
+ /**
+ * Disable a feature completely
+ *
+ * POST /actuator/features/{featureName}/disable
+ *
+ * @param featureName Name of the feature
+ * @return Success message
+ */
+ @PostMapping("/{featureName}/disable")
+ public ResponseEntity> disableFeature(@PathVariable String featureName) {
+ log.info("Disabling feature: {}", featureName);
+
+ featureToggleService.disableFeature(featureName);
+
+ Map response = new HashMap<>();
+ response.put("message", "Feature '" + featureName + "' disabled successfully");
+ response.put("status", "disabled");
+
+ return ResponseEntity.ok(response);
+ }
+
+ /**
+ * Set rollout percentage for gradual release
+ *
+ * PUT /actuator/features/{featureName}/rollout
+ *
+ * @param featureName Name of the feature
+ * @param percentage Rollout percentage (0-100)
+ * @return Success message with new percentage
+ */
+ @PutMapping("/{featureName}/rollout")
+ public ResponseEntity> setRolloutPercentage(
+ @PathVariable String featureName,
+ @RequestParam int percentage) {
+
+ if (percentage < 0 || percentage > 100) {
+ Map error = new HashMap<>();
+ error.put("error", "Percentage must be between 0 and 100");
+ return ResponseEntity.badRequest().body(error);
+ }
+
+ log.info("Setting rollout percentage for '{}' to {}%", featureName, percentage);
+
+ featureToggleService.setRolloutPercentage(featureName, percentage);
+
+ Map response = new HashMap<>();
+ response.put("message", "Rollout percentage updated successfully");
+ response.put("feature", featureName);
+ response.put("rolloutPercentage", percentage);
+
+ return ResponseEntity.ok(response);
+ }
+}
diff --git a/order-service/src/main/java/com/selimhorri/app/service/OrderMetricsService.java b/order-service/src/main/java/com/selimhorri/app/service/OrderMetricsService.java
new file mode 100644
index 000000000..65b448e33
--- /dev/null
+++ b/order-service/src/main/java/com/selimhorri/app/service/OrderMetricsService.java
@@ -0,0 +1,133 @@
+package com.selimhorri.app.service;
+
+import io.micrometer.core.instrument.Counter;
+import io.micrometer.core.instrument.Gauge;
+import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.Timer;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+
+/**
+ * Service for tracking business metrics related to orders
+ */
+@Service
+@Slf4j
+public class OrderMetricsService {
+
+ private final Counter ordersCreatedCounter;
+ private final Counter ordersCompletedCounter;
+ private final Counter ordersCancelledCounter;
+ private final Counter ordersFailedCounter;
+ private final AtomicLong totalOrderAmount;
+ private final AtomicInteger activeOrders;
+ private final Timer orderProcessingTimer;
+
+ public OrderMetricsService(MeterRegistry meterRegistry) {
+ // Counter for orders created
+ this.ordersCreatedCounter = Counter.builder("orders.created.total")
+ .description("Total number of orders created")
+ .tag("service", "order-service")
+ .register(meterRegistry);
+
+ // Counter for orders completed
+ this.ordersCompletedCounter = Counter.builder("orders.completed.total")
+ .description("Total number of orders completed successfully")
+ .tag("service", "order-service")
+ .register(meterRegistry);
+
+ // Counter for orders cancelled
+ this.ordersCancelledCounter = Counter.builder("orders.cancelled.total")
+ .description("Total number of orders cancelled")
+ .tag("service", "order-service")
+ .register(meterRegistry);
+
+ // Counter for orders failed
+ this.ordersFailedCounter = Counter.builder("orders.failed.total")
+ .description("Total number of orders that failed")
+ .tag("service", "order-service")
+ .register(meterRegistry);
+
+ // Gauge for total order amount
+ this.totalOrderAmount = new AtomicLong(0);
+ Gauge.builder("orders.amount.total", totalOrderAmount, AtomicLong::get)
+ .description("Total amount of all orders")
+ .tag("service", "order-service")
+ .register(meterRegistry);
+
+ // Gauge for active orders
+ this.activeOrders = new AtomicInteger(0);
+ Gauge.builder("orders.active.count", activeOrders, AtomicInteger::get)
+ .description("Number of active orders being processed")
+ .tag("service", "order-service")
+ .register(meterRegistry);
+
+ // Timer for order processing time
+ this.orderProcessingTimer = Timer.builder("orders.processing.time")
+ .description("Time taken to process an order")
+ .tag("service", "order-service")
+ .register(meterRegistry);
+ }
+
+ /**
+ * Record that an order was created
+ */
+ public void recordOrderCreated() {
+ ordersCreatedCounter.increment();
+ activeOrders.incrementAndGet();
+ log.debug("Order created metric recorded");
+ }
+
+ /**
+ * Record that an order was created with amount
+ */
+ public void recordOrderCreated(double amount) {
+ ordersCreatedCounter.increment();
+ totalOrderAmount.addAndGet((long) amount);
+ activeOrders.incrementAndGet();
+ log.debug("Order created with amount {} metric recorded", amount);
+ }
+
+ /**
+ * Record that an order was completed
+ */
+ public void recordOrderCompleted() {
+ ordersCompletedCounter.increment();
+ activeOrders.decrementAndGet();
+ log.debug("Order completed metric recorded");
+ }
+
+ /**
+ * Record that an order was cancelled
+ */
+ public void recordOrderCancelled() {
+ ordersCancelledCounter.increment();
+ activeOrders.decrementAndGet();
+ log.debug("Order cancelled metric recorded");
+ }
+
+ /**
+ * Record that an order failed
+ */
+ public void recordOrderFailed() {
+ ordersFailedCounter.increment();
+ activeOrders.decrementAndGet();
+ log.debug("Order failed metric recorded");
+ }
+
+ /**
+ * Get timer for recording order processing time
+ */
+ public Timer.Sample startOrderProcessing() {
+ return Timer.start();
+ }
+
+ /**
+ * Stop timer and record order processing time
+ */
+ public void stopOrderProcessing(Timer.Sample sample) {
+ sample.stop(orderProcessingTimer);
+ }
+}
diff --git a/order-service/src/main/resources/application.yml b/order-service/src/main/resources/application.yml
index 1713e8409..1c4d568a2 100644
--- a/order-service/src/main/resources/application.yml
+++ b/order-service/src/main/resources/application.yml
@@ -5,15 +5,21 @@ server:
spring:
zipkin:
- base-url: ${SPRING_ZIPKIN_BASE_URL:http://localhost:9411/}
+ base-url: ${SPRING_ZIPKIN_BASE_URL:http://zipkin:9411/}
config:
- import: ${SPRING_CONFIG_IMPORT:optional:configserver:http://localhost:9296}
+ import: ${SPRING_CONFIG_IMPORT:optional:configserver:http://cloud-config:9296}
application:
name: ORDER-SERVICE
profiles:
active:
- dev
+eureka:
+ client:
+ service-url:
+ defaultZone: ${EUREKA_CLIENT_SERVICEURL_DEFAULTZONE:http://service-discovery-container:8761/eureka/}
+
+
resilience4j:
circuitbreaker:
instances:
@@ -27,20 +33,104 @@ resilience4j:
sliding-window-size: 10
wait-duration-in-open-state: 5s
sliding-window-type: COUNT_BASED
+
+ # Bulkhead Pattern Configuration
+ bulkhead:
+ instances:
+ orderProcessing:
+ max-concurrent-calls: 10
+ max-wait-duration: 0ms
+ highPriorityOrders:
+ max-concurrent-calls: 5
+ max-wait-duration: 0ms
+
+ thread-pool-bulkhead:
+ instances:
+ orderAsyncProcessing:
+ max-thread-pool-size: 5
+ core-thread-pool-size: 3
+ queue-capacity: 20
+ keep-alive-duration: 20ms
+
+ # Retry Pattern Configuration
+ retry:
+ instances:
+ orderProcessing:
+ max-attempts: 3
+ wait-duration: 1000ms
+ exponential-backoff-multiplier: 2
+ retry-exceptions:
+ - java.net.ConnectException
+ - java.net.SocketTimeoutException
+ - org.springframework.web.client.HttpServerErrorException
+
+ externalApiCall:
+ max-attempts: 5
+ wait-duration: 500ms
+ exponential-backoff-multiplier: 1.5
+ enable-exponential-backoff: true
-management:
- health:
- circuitbreakers:
+# Feature Toggle Configuration
+features:
+ environment: ${SPRING_PROFILES_ACTIVE:dev}
+ toggles:
+ new-checkout-flow:
enabled: true
+ rollout-percentage: 50
+ description: "New optimized checkout flow with fewer steps"
+ enabled-environments:
+ - dev
+ - stage
+
+ advanced-order-analytics:
+ enabled: true
+ rollout-percentage: 10
+ description: "Advanced analytics and insights for orders"
+ enabled-users:
+ - admin@example.com
+
+ order-retry-mechanism:
+ enabled: true
+ rollout-percentage: 100
+ description: "Automatic retry for failed order processing"
+
+ bulk-order-processing:
+ enabled: true
+ rollout-percentage: 25
+ description: "Process multiple orders in a single transaction"
+ enabled-environments:
+ - dev
+
+ real-time-inventory:
+ enabled: false
+ rollout-percentage: 0
+ description: "Real-time inventory updates (experimental)"
+
+management:
+ endpoints:
+ web:
+ exposure:
+ include: health,info,metrics,prometheus,env,loggers,threaddump,heapdump,refresh,features
endpoint:
health:
show-details: always
-
-
-
-
-
-
-
-
-
+ probes:
+ enabled: true
+ metrics:
+ enabled: true
+ prometheus:
+ enabled: true
+ metrics:
+ export:
+ prometheus:
+ enabled: true
+ tags:
+ application: ${spring.application.name}
+ environment: ${spring.profiles.active}
+ health:
+ circuitbreakers:
+ enabled: true
+ livenessstate:
+ enabled: true
+ readinessstate:
+ enabled: true
diff --git a/order-service/src/main/resources/logback-spring.xml b/order-service/src/main/resources/logback-spring.xml
new file mode 100644
index 000000000..9a551a487
--- /dev/null
+++ b/order-service/src/main/resources/logback-spring.xml
@@ -0,0 +1,46 @@
+
+
+
+
+
+
+
+
+
+
+ {"app_name":"${appName}","app_port":"${appPort}"}
+ traceId
+ spanId
+
+
+
+
+
+ logstash:5000
+
+ {"app_name":"${appName}","app_port":"${appPort}"}
+ traceId
+ spanId
+
+ 5 minutes
+
+
+
+
+
+ 512
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/order-service/src/test/java/com/selimhorri/app/integration/OrderIntegrationTests.java b/order-service/src/test/java/com/selimhorri/app/integration/OrderIntegrationTests.java
new file mode 100644
index 000000000..e79408936
--- /dev/null
+++ b/order-service/src/test/java/com/selimhorri/app/integration/OrderIntegrationTests.java
@@ -0,0 +1,73 @@
+package com.selimhorri.app.integration;
+
+import com.selimhorri.app.domain.Order;
+import com.selimhorri.app.domain.Cart;
+import com.selimhorri.app.dto.OrderDto;
+import com.selimhorri.app.dto.CartDto;
+import com.selimhorri.app.repository.OrderRepository;
+import com.selimhorri.app.service.impl.OrderServiceImpl;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import java.time.LocalDateTime;
+import java.util.Optional;
+import java.util.Collections;
+import static org.junit.jupiter.api.Assertions.*;
+
+@SpringBootTest
+class OrderIntegrationTests {
+
+ @Autowired
+ private OrderServiceImpl service;
+
+ @MockBean
+ private OrderRepository repo;
+
+ @Test
+ void contextLoads() {
+ assertNotNull(service);
+ }
+
+ @Test
+ void testSaveIntegration() {
+ OrderDto dto = OrderDto.builder().orderId(10).orderDate(LocalDateTime.now()).orderDesc("desc").orderFee(5.0).cartDto(CartDto.builder().cartId(1).build()).build();
+ Order entity = Order.builder().orderId(10).orderDate(dto.getOrderDate()).orderDesc(dto.getOrderDesc()).orderFee(dto.getOrderFee()).cart(Cart.builder().cartId(1).build()).build();
+ Mockito.when(repo.save(Mockito.any())).thenReturn(entity);
+ OrderDto result = service.save(dto);
+ assertEquals(dto.getOrderId(), result.getOrderId());
+ }
+
+ @Test
+ void testUpdateIntegration() {
+ OrderDto dto = OrderDto.builder().orderId(10).orderDate(LocalDateTime.now()).orderDesc("desc").orderFee(5.0).cartDto(CartDto.builder().cartId(1).build()).build();
+ Order entity = Order.builder().orderId(10).orderDate(dto.getOrderDate()).orderDesc(dto.getOrderDesc()).orderFee(dto.getOrderFee()).cart(Cart.builder().cartId(1).build()).build();
+ Mockito.when(repo.save(Mockito.any())).thenReturn(entity);
+ OrderDto result = service.update(dto);
+ assertEquals(dto.getOrderId(), result.getOrderId());
+ }
+
+ @Test
+ void testDeleteByIdIntegration() {
+ Order order = Order.builder().orderId(10).orderDate(LocalDateTime.now()).orderDesc("desc").orderFee(5.0).cart(Cart.builder().cartId(1).build()).build();
+ Mockito.when(repo.findById(10)).thenReturn(Optional.of(order));
+ service.deleteById(10);
+ Mockito.verify(repo).delete(Mockito.any());
+ }
+
+ @Test
+ void testFindByIdIntegration() {
+ Order order = Order.builder().orderId(10).orderDate(LocalDateTime.now()).orderDesc("desc").orderFee(5.0).cart(Cart.builder().cartId(1).build()).build();
+ Mockito.when(repo.findById(10)).thenReturn(Optional.of(order));
+ OrderDto result = service.findById(10);
+ assertEquals(order.getOrderId(), result.getOrderId());
+ }
+
+ @Test
+ void testFindAllIntegration() {
+ Order order = Order.builder().orderId(10).orderDate(LocalDateTime.now()).orderDesc("desc").orderFee(5.0).cart(Cart.builder().cartId(1).build()).build();
+ Mockito.when(repo.findAll()).thenReturn(Collections.singletonList(order));
+ assertFalse(service.findAll().isEmpty());
+ }
+}
\ No newline at end of file
diff --git a/order-service/src/test/java/com/selimhorri/app/unit/OrderUnitTests.java b/order-service/src/test/java/com/selimhorri/app/unit/OrderUnitTests.java
new file mode 100644
index 000000000..6459f226b
--- /dev/null
+++ b/order-service/src/test/java/com/selimhorri/app/unit/OrderUnitTests.java
@@ -0,0 +1,68 @@
+package com.selimhorri.app.unit;
+
+import com.selimhorri.app.domain.Order;
+import com.selimhorri.app.domain.Cart;
+import com.selimhorri.app.dto.OrderDto;
+import com.selimhorri.app.dto.CartDto;
+import com.selimhorri.app.helper.OrderMappingHelper;
+import com.selimhorri.app.repository.OrderRepository;
+import com.selimhorri.app.service.impl.OrderServiceImpl;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import java.time.LocalDateTime;
+import java.util.Collections;
+import static org.junit.jupiter.api.Assertions.*;
+
+class OrderUnitTests {
+
+ @Test
+ void testMapOrderToDto() {
+ Cart cart = Cart.builder().cartId(1).build();
+ Order order = Order.builder().orderId(10).orderDate(LocalDateTime.now()).orderDesc("desc").orderFee(5.0).cart(cart).build();
+ OrderDto dto = OrderMappingHelper.map(order);
+ assertEquals(order.getOrderId(), dto.getOrderId());
+ assertEquals(order.getOrderDesc(), dto.getOrderDesc());
+ assertNotNull(dto.getCartDto());
+ }
+
+ @Test
+ void testMapDtoToOrder() {
+ CartDto cartDto = CartDto.builder().cartId(1).build();
+ OrderDto dto = OrderDto.builder().orderId(10).orderDate(LocalDateTime.now()).orderDesc("desc").orderFee(5.0).cartDto(cartDto).build();
+ Order order = OrderMappingHelper.map(dto);
+ assertEquals(dto.getOrderId(), order.getOrderId());
+ assertEquals(dto.getOrderDesc(), order.getOrderDesc());
+ assertNotNull(order.getCart());
+ }
+
+ @Test
+ void testSaveCallsRepository() {
+ OrderRepository repo = Mockito.mock(OrderRepository.class);
+ OrderServiceImpl service = new OrderServiceImpl(repo);
+ OrderDto dto = OrderDto.builder().orderId(10).orderDate(LocalDateTime.now()).orderDesc("desc").orderFee(5.0).cartDto(CartDto.builder().cartId(1).build()).build();
+ Order entity = OrderMappingHelper.map(dto);
+ Mockito.when(repo.save(Mockito.any())).thenReturn(entity);
+ OrderDto result = service.save(dto);
+ assertEquals(dto.getOrderId(), result.getOrderId());
+ }
+
+ @Test
+ void testUpdateCallsRepository() {
+ OrderRepository repo = Mockito.mock(OrderRepository.class);
+ OrderServiceImpl service = new OrderServiceImpl(repo);
+ OrderDto dto = OrderDto.builder().orderId(10).orderDate(LocalDateTime.now()).orderDesc("desc").orderFee(5.0).cartDto(CartDto.builder().cartId(1).build()).build();
+ Order entity = OrderMappingHelper.map(dto);
+ Mockito.when(repo.save(Mockito.any())).thenReturn(entity);
+ OrderDto result = service.update(dto);
+ assertEquals(dto.getOrderId(), result.getOrderId());
+ }
+
+ @Test
+ void testFindAllReturnsList() {
+ OrderRepository repo = Mockito.mock(OrderRepository.class);
+ OrderServiceImpl service = new OrderServiceImpl(repo);
+ Order order = Order.builder().orderId(10).orderDate(LocalDateTime.now()).orderDesc("desc").orderFee(5.0).cart(Cart.builder().cartId(1).build()).build();
+ Mockito.when(repo.findAll()).thenReturn(Collections.singletonList(order));
+ assertFalse(service.findAll().isEmpty());
+ }
+}
\ No newline at end of file
diff --git a/payment-service/Dockerfile b/payment-service/Dockerfile
index 57d5b931c..b59e40639 100644
--- a/payment-service/Dockerfile
+++ b/payment-service/Dockerfile
@@ -3,10 +3,8 @@ FROM openjdk:11
ARG PROJECT_VERSION=0.1.0
RUN mkdir -p /home/app
WORKDIR /home/app
-ENV SPRING_PROFILES_ACTIVE dev
+ENV SPRING_PROFILES_ACTIVE=dev
COPY payment-service/ .
ADD payment-service/target/payment-service-v${PROJECT_VERSION}.jar payment-service.jar
EXPOSE 8400
-ENTRYPOINT ["java", "-Dspring.profiles.active=${SPRING_PROFILES_ACTIVE}", "-jar", "payment-service.jar"]
-
-
+ENTRYPOINT ["java", "-Dspring.profiles.active=${SPRING_PROFILES_ACTIVE}", "-jar", "payment-service.jar"]
\ No newline at end of file
diff --git a/payment-service/compose.yml b/payment-service/compose.yml
index 4c3539d19..c64932a5b 100644
--- a/payment-service/compose.yml
+++ b/payment-service/compose.yml
@@ -1,12 +1,22 @@
-
version: '3'
services:
payment-service-container:
- image: selimhorri/payment-service-ecommerce-boot:0.1.0
+ image: juanse201/payment-service-ecommerce-boot:0.1.0
ports:
- 8400:8400
environment:
- SPRING_PROFILES_ACTIVE=dev
-
+ - SPRING_ZIPKIN_BASE_URL=http://zipkin:9411
+ - SPRING_CONFIG_IMPORT=optional:configserver:http://cloud-config-container:9296/
+ - EUREKA_CLIENT_REGION=default
+ - EUREKA_CLIENT_AVAILABILITY_ZONES_DEFAULT=myzone
+ - EUREKA_CLIENT_SERVICEURL_MYZONE=http://service-discovery-container:8761/eureka
+ - EUREKA_CLIENT_SERVICEURL_DEFAULTZONE=http://service-discovery-container:8761/eureka/
+ networks:
+ - microservices_network
+networks:
+ microservices_network:
+ external: true
+ name: microservices_network
diff --git a/payment-service/pom.xml b/payment-service/pom.xml
index 0f3da9562..8121dafc4 100644
--- a/payment-service/pom.xml
+++ b/payment-service/pom.xml
@@ -73,6 +73,23 @@
mysql
test
+
+ org.springframework.boot
+ spring-boot-starter-actuator
+
+
+ io.micrometer
+ micrometer-registry-prometheus
+
+
+ net.logstash.logback
+ logstash-logback-encoder
+ 7.3
+
+
+ org.springframework.cloud
+ spring-cloud-starter-sleuth
+
diff --git a/payment-service/src/main/java/com/selimhorri/app/health/DatabaseHealthIndicator.java b/payment-service/src/main/java/com/selimhorri/app/health/DatabaseHealthIndicator.java
new file mode 100644
index 000000000..261ec76e2
--- /dev/null
+++ b/payment-service/src/main/java/com/selimhorri/app/health/DatabaseHealthIndicator.java
@@ -0,0 +1,53 @@
+package com.selimhorri.app.health;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.boot.actuate.health.Health;
+import org.springframework.boot.actuate.health.HealthIndicator;
+import org.springframework.stereotype.Component;
+
+import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.Statement;
+
+/**
+ * Custom health indicator for database connectivity
+ */
+@Component("database")
+@RequiredArgsConstructor
+@Slf4j
+public class DatabaseHealthIndicator implements HealthIndicator {
+
+ private final DataSource dataSource;
+
+ @Override
+ public Health health() {
+ try (Connection connection = dataSource.getConnection();
+ Statement statement = connection.createStatement();
+ ResultSet resultSet = statement.executeQuery("SELECT 1")) {
+
+ if (resultSet.next()) {
+ // Get database metadata
+ String databaseProductName = connection.getMetaData().getDatabaseProductName();
+ String databaseProductVersion = connection.getMetaData().getDatabaseProductVersion();
+
+ return Health.up()
+ .withDetail("database", databaseProductName)
+ .withDetail("version", databaseProductVersion)
+ .withDetail("status", "Connected")
+ .build();
+ } else {
+ return Health.down()
+ .withDetail("status", "Unable to validate connection")
+ .build();
+ }
+ } catch (Exception e) {
+ log.error("Database health check failed", e);
+ return Health.down()
+ .withDetail("error", e.getMessage())
+ .withException(e)
+ .build();
+ }
+ }
+}
diff --git a/payment-service/src/main/java/com/selimhorri/app/service/PaymentMetricsService.java b/payment-service/src/main/java/com/selimhorri/app/service/PaymentMetricsService.java
new file mode 100644
index 000000000..4306122ea
--- /dev/null
+++ b/payment-service/src/main/java/com/selimhorri/app/service/PaymentMetricsService.java
@@ -0,0 +1,97 @@
+package com.selimhorri.app.service;
+
+import io.micrometer.core.instrument.Counter;
+import io.micrometer.core.instrument.Gauge;
+import io.micrometer.core.instrument.MeterRegistry;
+import io.micrometer.core.instrument.Timer;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.util.concurrent.atomic.AtomicLong;
+
+/**
+ * Service for tracking business metrics related to payments
+ */
+@Service
+@Slf4j
+public class PaymentMetricsService {
+
+ private final Counter paymentsProcessedCounter;
+ private final Counter paymentsFailedCounter;
+ private final Counter paymentsRefundedCounter;
+ private final AtomicLong totalPaymentAmount;
+ private final Timer paymentProcessingTimer;
+
+ public PaymentMetricsService(MeterRegistry meterRegistry) {
+ // Counter for payments processed
+ this.paymentsProcessedCounter = Counter.builder("payments.processed.total")
+ .description("Total number of payments processed successfully")
+ .tag("service", "payment-service")
+ .register(meterRegistry);
+
+ // Counter for payments failed
+ this.paymentsFailedCounter = Counter.builder("payments.failed.total")
+ .description("Total number of payments that failed")
+ .tag("service", "payment-service")
+ .register(meterRegistry);
+
+ // Counter for payments refunded
+ this.paymentsRefundedCounter = Counter.builder("payments.refunded.total")
+ .description("Total number of payments refunded")
+ .tag("service", "payment-service")
+ .register(meterRegistry);
+
+ // Gauge for total payment amount
+ this.totalPaymentAmount = new AtomicLong(0);
+ Gauge.builder("payments.amount.total", totalPaymentAmount, AtomicLong::get)
+ .description("Total amount of all payments processed")
+ .tag("service", "payment-service")
+ .register(meterRegistry);
+
+ // Timer for payment processing time
+ this.paymentProcessingTimer = Timer.builder("payments.processing.time")
+ .description("Time taken to process a payment")
+ .tag("service", "payment-service")
+ .register(meterRegistry);
+ }
+
+ /**
+ * Record that a payment was processed successfully
+ */
+ public void recordPaymentProcessed(double amount) {
+ paymentsProcessedCounter.increment();
+ totalPaymentAmount.addAndGet((long) amount);
+ log.debug("Payment processed metric recorded with amount {}", amount);
+ }
+
+ /**
+ * Record that a payment failed
+ */
+ public void recordPaymentFailed() {
+ paymentsFailedCounter.increment();
+ log.debug("Payment failed metric recorded");
+ }
+
+ /**
+ * Record that a payment was refunded
+ */
+ public void recordPaymentRefunded(double amount) {
+ paymentsRefundedCounter.increment();
+ totalPaymentAmount.addAndGet(-((long) amount));
+ log.debug("Payment refunded metric recorded with amount {}", amount);
+ }
+
+ /**
+ * Get timer for recording payment processing time
+ */
+ public Timer.Sample startPaymentProcessing() {
+ return Timer.start();
+ }
+
+ /**
+ * Stop timer and record payment processing time
+ */
+ public void stopPaymentProcessing(Timer.Sample sample) {
+ sample.stop(paymentProcessingTimer);
+ }
+}
diff --git a/payment-service/src/main/resources/application.yml b/payment-service/src/main/resources/application.yml
index f595a0bf3..f7fbbfcea 100644
--- a/payment-service/src/main/resources/application.yml
+++ b/payment-service/src/main/resources/application.yml
@@ -5,15 +5,21 @@ server:
spring:
zipkin:
- base-url: ${SPRING_ZIPKIN_BASE_URL:http://localhost:9411/}
+ base-url: ${SPRING_ZIPKIN_BASE_URL:http://zipkin:9411/}
config:
- import: ${SPRING_CONFIG_IMPORT:optional:configserver:http://localhost:9296}
+ import: ${SPRING_CONFIG_IMPORT:optional:configserver:http://cloud-config:9296}
application:
name: PAYMENT-SERVICE
profiles:
active:
- dev
+eureka:
+ client:
+ service-url:
+ defaultZone: ${EUREKA_CLIENT_SERVICEURL_DEFAULTZONE:http://service-discovery-container:8761/eureka/}
+
+
resilience4j:
circuitbreaker:
instances:
@@ -29,12 +35,33 @@ resilience4j:
sliding-window-type: COUNT_BASED
management:
- health:
- circuitbreakers:
- enabled: true
+ endpoints:
+ web:
+ exposure:
+ include: health,info,metrics,prometheus,env,loggers,threaddump,heapdump
endpoint:
health:
show-details: always
+ probes:
+ enabled: true
+ metrics:
+ enabled: true
+ prometheus:
+ enabled: true
+ metrics:
+ export:
+ prometheus:
+ enabled: true
+ tags:
+ application: ${spring.application.name}
+ environment: ${spring.profiles.active}
+ health:
+ circuitbreakers:
+ enabled: true
+ livenessstate:
+ enabled: true
+ readinessstate:
+ enabled: true
diff --git a/payment-service/src/main/resources/logback-spring.xml b/payment-service/src/main/resources/logback-spring.xml
new file mode 100644
index 000000000..9a551a487
--- /dev/null
+++ b/payment-service/src/main/resources/logback-spring.xml
@@ -0,0 +1,46 @@
+
+
+
+
+
+
+
+
+
+
+ {"app_name":"${appName}","app_port":"${appPort}"}
+ traceId
+ spanId
+
+
+
+
+
+ logstash:5000
+
+ {"app_name":"${appName}","app_port":"${appPort}"}
+ traceId
+ spanId
+
+ 5 minutes
+
+
+
+
+
+ 512
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/payment-service/src/test/java/com/selimhorri/app/integration/PaymentIntegrationTests.java b/payment-service/src/test/java/com/selimhorri/app/integration/PaymentIntegrationTests.java
new file mode 100644
index 000000000..1d44f3bb9
--- /dev/null
+++ b/payment-service/src/test/java/com/selimhorri/app/integration/PaymentIntegrationTests.java
@@ -0,0 +1,70 @@
+package com.selimhorri.app.integration;
+
+import com.selimhorri.app.domain.Payment;
+import com.selimhorri.app.dto.PaymentDto;
+import com.selimhorri.app.dto.OrderDto;
+import com.selimhorri.app.repository.PaymentRepository;
+import com.selimhorri.app.service.impl.PaymentServiceImpl;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.web.client.RestTemplate;
+import java.util.Optional;
+import static org.junit.jupiter.api.Assertions.*;
+
+@SpringBootTest
+class PaymentIntegrationTests {
+
+ @Autowired
+ private PaymentServiceImpl service;
+
+ @MockBean
+ private PaymentRepository repo;
+
+ @MockBean
+ private RestTemplate restTemplate;
+
+ @Test
+ void contextLoads() {
+ assertNotNull(service);
+ }
+
+
+ @Test
+ void testSaveIntegration() {
+ // Set orderDto to avoid NullPointerException in mapping/service logic
+ OrderDto orderDto = OrderDto.builder().orderId(2).build();
+ PaymentDto dto = PaymentDto.builder().paymentId(1).isPayed(true).paymentStatus(null).orderDto(orderDto).build();
+ Payment entity = Payment.builder().paymentId(1).isPayed(true).paymentStatus(null).orderId(2).build();
+ Mockito.when(repo.save(Mockito.any())).thenReturn(entity);
+ PaymentDto result = service.save(dto);
+ assertEquals(dto.getPaymentId(), result.getPaymentId());
+ }
+
+ @Test
+ void testUpdateIntegration() {
+ OrderDto orderDto = OrderDto.builder().orderId(2).build();
+ PaymentDto dto = PaymentDto.builder().paymentId(1).isPayed(true).paymentStatus(null).orderDto(orderDto).build();
+ Payment entity = Payment.builder().paymentId(1).isPayed(true).paymentStatus(null).orderId(2).build();
+ Mockito.when(repo.save(Mockito.any())).thenReturn(entity);
+ PaymentDto result = service.update(dto);
+ assertEquals(dto.getPaymentId(), result.getPaymentId());
+ }
+
+ @Test
+ void testDeleteByIdIntegration() {
+ service.deleteById(1);
+ Mockito.verify(repo).deleteById(1);
+ }
+
+ @Test
+ void testFindByIdIntegration() {
+ Payment entity = Payment.builder().paymentId(1).isPayed(true).paymentStatus(null).orderId(2).build();
+ Mockito.when(repo.findById(1)).thenReturn(Optional.of(entity));
+ Mockito.when(restTemplate.getForObject(Mockito.anyString(), Mockito.any())).thenReturn(com.selimhorri.app.dto.OrderDto.builder().orderId(2).build());
+ PaymentDto result = service.findById(1);
+ assertEquals(entity.getPaymentId(), result.getPaymentId());
+ }
+}
\ No newline at end of file
diff --git a/payment-service/src/test/java/com/selimhorri/app/unit/PaymentUnitTests.java b/payment-service/src/test/java/com/selimhorri/app/unit/PaymentUnitTests.java
new file mode 100644
index 000000000..395a7b529
--- /dev/null
+++ b/payment-service/src/test/java/com/selimhorri/app/unit/PaymentUnitTests.java
@@ -0,0 +1,71 @@
+package com.selimhorri.app.unit;
+
+import com.selimhorri.app.domain.Payment;
+import com.selimhorri.app.dto.PaymentDto;
+import com.selimhorri.app.dto.OrderDto;
+import com.selimhorri.app.helper.PaymentMappingHelper;
+import com.selimhorri.app.repository.PaymentRepository;
+import com.selimhorri.app.service.impl.PaymentServiceImpl;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import org.springframework.web.client.RestTemplate;
+import static org.junit.jupiter.api.Assertions.*;
+
+class PaymentUnitTests {
+
+
+ @Test
+ void testMapPaymentToDto() {
+ Payment payment = Payment.builder().paymentId(1).isPayed(true).paymentStatus(null).orderId(2).build();
+ PaymentDto dto = PaymentMappingHelper.map(payment);
+ assertEquals(payment.getPaymentId(), dto.getPaymentId());
+ assertEquals(payment.getIsPayed(), dto.getIsPayed());
+ assertEquals(payment.getPaymentStatus(), dto.getPaymentStatus());
+ }
+
+ @Test
+ void testMapDtoToPayment() {
+ OrderDto orderDto = OrderDto.builder().orderId(2).build();
+ PaymentDto dto = PaymentDto.builder().paymentId(1).isPayed(true).paymentStatus(null).orderDto(orderDto).build();
+ Payment payment = PaymentMappingHelper.map(dto);
+ assertEquals(dto.getPaymentId(), payment.getPaymentId());
+ assertEquals(dto.getIsPayed(), payment.getIsPayed());
+ assertEquals(dto.getPaymentStatus(), payment.getPaymentStatus());
+ }
+
+
+ @Test
+ void testSaveCallsRepository() {
+ PaymentRepository repo = Mockito.mock(PaymentRepository.class);
+ RestTemplate restTemplate = Mockito.mock(RestTemplate.class);
+ PaymentServiceImpl service = new PaymentServiceImpl(repo, restTemplate);
+ OrderDto orderDto = OrderDto.builder().orderId(2).build();
+ PaymentDto dto = PaymentDto.builder().paymentId(1).isPayed(true).paymentStatus(null).orderDto(orderDto).build();
+ Payment entity = PaymentMappingHelper.map(dto);
+ Mockito.when(repo.save(Mockito.any())).thenReturn(entity);
+ PaymentDto result = service.save(dto);
+ assertEquals(dto.getPaymentId(), result.getPaymentId());
+ }
+
+ @Test
+ void testUpdateCallsRepository() {
+ PaymentRepository repo = Mockito.mock(PaymentRepository.class);
+ RestTemplate restTemplate = Mockito.mock(RestTemplate.class);
+ PaymentServiceImpl service = new PaymentServiceImpl(repo, restTemplate);
+ OrderDto orderDto = OrderDto.builder().orderId(2).build();
+ PaymentDto dto = PaymentDto.builder().paymentId(1).isPayed(true).paymentStatus(null).orderDto(orderDto).build();
+ Payment entity = PaymentMappingHelper.map(dto);
+ Mockito.when(repo.save(Mockito.any())).thenReturn(entity);
+ PaymentDto result = service.update(dto);
+ assertEquals(dto.getPaymentId(), result.getPaymentId());
+ }
+
+ @Test
+ void testDeleteByIdCallsRepository() {
+ PaymentRepository repo = Mockito.mock(PaymentRepository.class);
+ RestTemplate restTemplate = Mockito.mock(RestTemplate.class);
+ PaymentServiceImpl service = new PaymentServiceImpl(repo, restTemplate);
+ service.deleteById(1);
+ Mockito.verify(repo).deleteById(1);
+ }
+}
\ No newline at end of file
diff --git a/pom.xml b/pom.xml
index 832247436..8c972e38f 100644
--- a/pom.xml
+++ b/pom.xml
@@ -32,6 +32,10 @@
org.springframework.boot
spring-boot-starter-actuator
+
+ org.springframework.boot
+ spring-boot-starter-actuator
+
org.springframework.cloud
spring-cloud-starter-circuitbreaker-resilience4j
diff --git a/product-service/Dockerfile b/product-service/Dockerfile
index c052995cf..f73406b40 100644
--- a/product-service/Dockerfile
+++ b/product-service/Dockerfile
@@ -3,10 +3,8 @@ FROM openjdk:11
ARG PROJECT_VERSION=0.1.0
RUN mkdir -p /home/app
WORKDIR /home/app
-ENV SPRING_PROFILES_ACTIVE dev
+ENV SPRING_PROFILES_ACTIVE=dev
COPY product-service/ .
ADD product-service/target/product-service-v${PROJECT_VERSION}.jar product-service.jar
EXPOSE 8500
-ENTRYPOINT ["java", "-Dspring.profiles.active=${SPRING_PROFILES_ACTIVE}", "-jar", "product-service.jar"]
-
-
+ENTRYPOINT ["java", "-Dspring.profiles.active=${SPRING_PROFILES_ACTIVE}", "-jar", "product-service.jar"]
\ No newline at end of file
diff --git a/product-service/compose.yml b/product-service/compose.yml
index 618eb819a..3f8286fa3 100644
--- a/product-service/compose.yml
+++ b/product-service/compose.yml
@@ -1,12 +1,23 @@
-
version: '3'
services:
product-service-container:
- image: selimhorri/product-service-ecommerce-boot:0.1.0
+ image: juanse201/product-service-ecommerce-boot:0.1.0
ports:
- 8500:8500
environment:
- SPRING_PROFILES_ACTIVE=dev
+ - SPRING_ZIPKIN_BASE_URL=http://zipkin:9411
+ - SPRING_CONFIG_IMPORT=optional:configserver:http://cloud-config-container:9296/
+ - EUREKA_CLIENT_REGION=default
+ - EUREKA_CLIENT_AVAILABILITY_ZONES_DEFAULT=myzone
+ - EUREKA_CLIENT_SERVICEURL_MYZONE=http://service-discovery-container:8761/eureka
+ - EUREKA_CLIENT_SERVICEURL_DEFAULTZONE=http://service-discovery-container:8761/eureka/
+ networks:
+ - microservices_network
+networks:
+ microservices_network:
+ external: true
+ name: microservices_network
diff --git a/product-service/pom.xml b/product-service/pom.xml
index ac89c6c8a..63ebccfba 100644
--- a/product-service/pom.xml
+++ b/product-service/pom.xml
@@ -73,6 +73,23 @@
mysql
test
+
+ org.springframework.boot
+ spring-boot-starter-actuator
+
+
+ io.micrometer
+ micrometer-registry-prometheus
+
+
+ net.logstash.logback
+ logstash-logback-encoder
+ 7.3
+
+
+ org.springframework.cloud
+ spring-cloud-starter-sleuth
+
diff --git a/product-service/src/main/java/com/selimhorri/app/health/DatabaseHealthIndicator.java b/product-service/src/main/java/com/selimhorri/app/health/DatabaseHealthIndicator.java
new file mode 100644
index 000000000..261ec76e2
--- /dev/null
+++ b/product-service/src/main/java/com/selimhorri/app/health/DatabaseHealthIndicator.java
@@ -0,0 +1,53 @@
+package com.selimhorri.app.health;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.boot.actuate.health.Health;
+import org.springframework.boot.actuate.health.HealthIndicator;
+import org.springframework.stereotype.Component;
+
+import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.Statement;
+
+/**
+ * Custom health indicator for database connectivity
+ */
+@Component("database")
+@RequiredArgsConstructor
+@Slf4j
+public class DatabaseHealthIndicator implements HealthIndicator {
+
+ private final DataSource dataSource;
+
+ @Override
+ public Health health() {
+ try (Connection connection = dataSource.getConnection();
+ Statement statement = connection.createStatement();
+ ResultSet resultSet = statement.executeQuery("SELECT 1")) {
+
+ if (resultSet.next()) {
+ // Get database metadata
+ String databaseProductName = connection.getMetaData().getDatabaseProductName();
+ String databaseProductVersion = connection.getMetaData().getDatabaseProductVersion();
+
+ return Health.up()
+ .withDetail("database", databaseProductName)
+ .withDetail("version", databaseProductVersion)
+ .withDetail("status", "Connected")
+ .build();
+ } else {
+ return Health.down()
+ .withDetail("status", "Unable to validate connection")
+ .build();
+ }
+ } catch (Exception e) {
+ log.error("Database health check failed", e);
+ return Health.down()
+ .withDetail("error", e.getMessage())
+ .withException(e)
+ .build();
+ }
+ }
+}
diff --git a/product-service/src/main/java/com/selimhorri/app/service/ProductMetricsService.java b/product-service/src/main/java/com/selimhorri/app/service/ProductMetricsService.java
new file mode 100644
index 000000000..b7ad28f79
--- /dev/null
+++ b/product-service/src/main/java/com/selimhorri/app/service/ProductMetricsService.java
@@ -0,0 +1,112 @@
+package com.selimhorri.app.service;
+
+import io.micrometer.core.instrument.Counter;
+import io.micrometer.core.instrument.Gauge;
+import io.micrometer.core.instrument.MeterRegistry;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Service for tracking business metrics related to products
+ */
+@Service
+@Slf4j
+public class ProductMetricsService {
+
+ private final Counter productsCreatedCounter;
+ private final Counter productsViewedCounter;
+ private final Counter productsUpdatedCounter;
+ private final Counter productsDeletedCounter;
+ private final AtomicInteger lowStockProducts;
+
+ public ProductMetricsService(MeterRegistry meterRegistry) {
+ // Counter for products created
+ this.productsCreatedCounter = Counter.builder("products.created.total")
+ .description("Total number of products created")
+ .tag("service", "product-service")
+ .register(meterRegistry);
+
+ // Counter for product views
+ this.productsViewedCounter = Counter.builder("products.views.total")
+ .description("Total number of product views")
+ .tag("service", "product-service")
+ .register(meterRegistry);
+
+ // Counter for products updated
+ this.productsUpdatedCounter = Counter.builder("products.updated.total")
+ .description("Total number of products updated")
+ .tag("service", "product-service")
+ .register(meterRegistry);
+
+ // Counter for products deleted
+ this.productsDeletedCounter = Counter.builder("products.deleted.total")
+ .description("Total number of products deleted")
+ .tag("service", "product-service")
+ .register(meterRegistry);
+
+ // Gauge for low stock products
+ this.lowStockProducts = new AtomicInteger(0);
+ Gauge.builder("products.stock.low", lowStockProducts, AtomicInteger::get)
+ .description("Number of products with low stock levels")
+ .tag("service", "product-service")
+ .register(meterRegistry);
+ }
+
+ /**
+ * Record that a product was created
+ */
+ public void recordProductCreated() {
+ productsCreatedCounter.increment();
+ log.debug("Product created metric recorded");
+ }
+
+ /**
+ * Record that a product was viewed
+ */
+ public void recordProductViewed() {
+ productsViewedCounter.increment();
+ log.debug("Product view metric recorded");
+ }
+
+ /**
+ * Record that a product was updated
+ */
+ public void recordProductUpdated() {
+ productsUpdatedCounter.increment();
+ log.debug("Product updated metric recorded");
+ }
+
+ /**
+ * Record that a product was deleted
+ */
+ public void recordProductDeleted() {
+ productsDeletedCounter.increment();
+ log.debug("Product deleted metric recorded");
+ }
+
+ /**
+ * Update low stock products count
+ */
+ public void updateLowStockCount(int count) {
+ lowStockProducts.set(count);
+ log.debug("Low stock products count updated to {}", count);
+ }
+
+ /**
+ * Increment low stock products count
+ */
+ public void incrementLowStockCount() {
+ lowStockProducts.incrementAndGet();
+ log.debug("Low stock products count incremented");
+ }
+
+ /**
+ * Decrement low stock products count
+ */
+ public void decrementLowStockCount() {
+ lowStockProducts.decrementAndGet();
+ log.debug("Low stock products count decremented");
+ }
+}
diff --git a/product-service/src/main/resources/application.yml b/product-service/src/main/resources/application.yml
index 75c2b0a46..eec1d3ad8 100644
--- a/product-service/src/main/resources/application.yml
+++ b/product-service/src/main/resources/application.yml
@@ -5,15 +5,20 @@ server:
spring:
zipkin:
- base-url: ${SPRING_ZIPKIN_BASE_URL:http://localhost:9411/}
+ base-url: ${SPRING_ZIPKIN_BASE_URL:http://zipkin:9411/}
config:
- import: ${SPRING_CONFIG_IMPORT:optional:configserver:http://localhost:9296}
+ import: ${SPRING_CONFIG_IMPORT:optional:configserver:http://cloud-config:9296}
application:
name: PRODUCT-SERVICE
profiles:
active:
- dev
+eureka:
+ client:
+ service-url:
+ defaultZone: ${EUREKA_CLIENT_SERVICEURL_DEFAULTZONE:http://service-discovery-container:8761/eureka/}
+
resilience4j:
circuitbreaker:
instances:
@@ -29,12 +34,33 @@ resilience4j:
sliding-window-type: COUNT_BASED
management:
- health:
- circuitbreakers:
- enabled: true
+ endpoints:
+ web:
+ exposure:
+ include: health,info,metrics,prometheus,env,loggers,threaddump,heapdump
endpoint:
health:
show-details: always
+ probes:
+ enabled: true
+ metrics:
+ enabled: true
+ prometheus:
+ enabled: true
+ metrics:
+ export:
+ prometheus:
+ enabled: true
+ tags:
+ application: ${spring.application.name}
+ environment: ${spring.profiles.active}
+ health:
+ circuitbreakers:
+ enabled: true
+ livenessstate:
+ enabled: true
+ readinessstate:
+ enabled: true
diff --git a/product-service/src/main/resources/logback-spring.xml b/product-service/src/main/resources/logback-spring.xml
new file mode 100644
index 000000000..9a551a487
--- /dev/null
+++ b/product-service/src/main/resources/logback-spring.xml
@@ -0,0 +1,46 @@
+
+
+
+
+
+
+
+
+
+
+ {"app_name":"${appName}","app_port":"${appPort}"}
+ traceId
+ spanId
+
+
+
+
+
+ logstash:5000
+
+ {"app_name":"${appName}","app_port":"${appPort}"}
+ traceId
+ spanId
+
+ 5 minutes
+
+
+
+
+
+ 512
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/product-service/src/test/java/com/selimhorri/app/integration/ProductIntegrationTests.java b/product-service/src/test/java/com/selimhorri/app/integration/ProductIntegrationTests.java
new file mode 100644
index 000000000..9b5cf7eeb
--- /dev/null
+++ b/product-service/src/test/java/com/selimhorri/app/integration/ProductIntegrationTests.java
@@ -0,0 +1,72 @@
+package com.selimhorri.app.integration;
+
+import com.selimhorri.app.domain.Product;
+import com.selimhorri.app.domain.Category;
+import com.selimhorri.app.dto.ProductDto;
+import com.selimhorri.app.dto.CategoryDto;
+import com.selimhorri.app.repository.ProductRepository;
+import com.selimhorri.app.service.impl.ProductServiceImpl;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import java.util.Optional;
+import java.util.Collections;
+import static org.junit.jupiter.api.Assertions.*;
+
+@SpringBootTest
+class ProductIntegrationTests {
+
+ @Autowired
+ private ProductServiceImpl service;
+
+ @MockBean
+ private ProductRepository repo;
+
+ @Test
+ void contextLoads() {
+ assertNotNull(service);
+ }
+
+ @Test
+ void testSaveIntegration() {
+ ProductDto dto = ProductDto.builder().productId(10).productTitle("Test").priceUnit(99.99).categoryDto(CategoryDto.builder().categoryId(1).build()).build();
+ Product entity = Product.builder().productId(10).productTitle("Test").priceUnit(99.99).category(Category.builder().categoryId(1).build()).build();
+ Mockito.when(repo.save(Mockito.any())).thenReturn(entity);
+ ProductDto result = service.save(dto);
+ assertEquals(dto.getProductId(), result.getProductId());
+ }
+
+ @Test
+ void testUpdateIntegration() {
+ ProductDto dto = ProductDto.builder().productId(10).productTitle("Test").priceUnit(99.99).categoryDto(CategoryDto.builder().categoryId(1).build()).build();
+ Product entity = Product.builder().productId(10).productTitle("Test").priceUnit(99.99).category(Category.builder().categoryId(1).build()).build();
+ Mockito.when(repo.save(Mockito.any())).thenReturn(entity);
+ ProductDto result = service.update(dto);
+ assertEquals(dto.getProductId(), result.getProductId());
+ }
+
+ @Test
+ void testDeleteByIdIntegration() {
+ Product product = Product.builder().productId(10).productTitle("Test").priceUnit(99.99).category(Category.builder().categoryId(1).build()).build();
+ Mockito.when(repo.findById(10)).thenReturn(Optional.of(product));
+ service.deleteById(10);
+ Mockito.verify(repo).delete(Mockito.any());
+ }
+
+ @Test
+ void testFindByIdIntegration() {
+ Product product = Product.builder().productId(10).productTitle("Test").priceUnit(99.99).category(Category.builder().categoryId(1).build()).build();
+ Mockito.when(repo.findById(10)).thenReturn(Optional.of(product));
+ ProductDto result = service.findById(10);
+ assertEquals(product.getProductId(), result.getProductId());
+ }
+
+ @Test
+ void testFindAllIntegration() {
+ Product product = Product.builder().productId(10).productTitle("Test").priceUnit(99.99).category(Category.builder().categoryId(1).build()).build();
+ Mockito.when(repo.findAll()).thenReturn(Collections.singletonList(product));
+ assertFalse(service.findAll().isEmpty());
+ }
+}
\ No newline at end of file
diff --git a/product-service/src/test/java/com/selimhorri/app/unit/ProductUnitTests.java b/product-service/src/test/java/com/selimhorri/app/unit/ProductUnitTests.java
new file mode 100644
index 000000000..97e9cc9db
--- /dev/null
+++ b/product-service/src/test/java/com/selimhorri/app/unit/ProductUnitTests.java
@@ -0,0 +1,72 @@
+package com.selimhorri.app.unit;
+
+import com.selimhorri.app.domain.Product;
+import com.selimhorri.app.domain.Category;
+import com.selimhorri.app.dto.ProductDto;
+import com.selimhorri.app.dto.CategoryDto;
+import com.selimhorri.app.helper.ProductMappingHelper;
+import com.selimhorri.app.repository.ProductRepository;
+import com.selimhorri.app.service.impl.ProductServiceImpl;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import java.util.Collections;
+import static org.junit.jupiter.api.Assertions.*;
+
+class ProductUnitTests {
+
+
+ @Test
+ void testMapProductToDto() {
+ Category category = Category.builder().categoryId(1).build();
+ Product product = Product.builder().productId(10).productTitle("Test").priceUnit(99.99).category(category).build();
+ ProductDto dto = ProductMappingHelper.map(product);
+ assertEquals(product.getProductId(), dto.getProductId());
+ assertEquals(product.getProductTitle(), dto.getProductTitle());
+ assertNotNull(dto.getCategoryDto());
+ }
+
+
+ @Test
+ void testMapDtoToProduct() {
+ CategoryDto categoryDto = CategoryDto.builder().categoryId(1).build();
+ ProductDto dto = ProductDto.builder().productId(10).productTitle("Test").priceUnit(99.99).categoryDto(categoryDto).build();
+ Product product = ProductMappingHelper.map(dto);
+ assertEquals(dto.getProductId(), product.getProductId());
+ assertEquals(dto.getProductTitle(), product.getProductTitle());
+ assertNotNull(product.getCategory());
+ }
+
+
+ @Test
+ void testSaveCallsRepository() {
+ ProductRepository repo = Mockito.mock(ProductRepository.class);
+ ProductServiceImpl service = new ProductServiceImpl(repo);
+ ProductDto dto = ProductDto.builder().productId(10).productTitle("Test").priceUnit(99.99).categoryDto(CategoryDto.builder().categoryId(1).build()).build();
+ Product entity = ProductMappingHelper.map(dto);
+ Mockito.when(repo.save(Mockito.any())).thenReturn(entity);
+ ProductDto result = service.save(dto);
+ assertEquals(dto.getProductId(), result.getProductId());
+ }
+
+
+ @Test
+ void testUpdateCallsRepository() {
+ ProductRepository repo = Mockito.mock(ProductRepository.class);
+ ProductServiceImpl service = new ProductServiceImpl(repo);
+ ProductDto dto = ProductDto.builder().productId(10).productTitle("Test").priceUnit(99.99).categoryDto(CategoryDto.builder().categoryId(1).build()).build();
+ Product entity = ProductMappingHelper.map(dto);
+ Mockito.when(repo.save(Mockito.any())).thenReturn(entity);
+ ProductDto result = service.update(dto);
+ assertEquals(dto.getProductId(), result.getProductId());
+ }
+
+
+ @Test
+ void testFindAllReturnsList() {
+ ProductRepository repo = Mockito.mock(ProductRepository.class);
+ ProductServiceImpl service = new ProductServiceImpl(repo);
+ Product product = Product.builder().productId(10).productTitle("Test").priceUnit(99.99).category(Category.builder().categoryId(1).build()).build();
+ Mockito.when(repo.findAll()).thenReturn(Collections.singletonList(product));
+ assertFalse(service.findAll().isEmpty());
+ }
+}
\ No newline at end of file
diff --git a/prometheus/alert.rules.yml b/prometheus/alert.rules.yml
new file mode 100644
index 000000000..3a204a3f9
--- /dev/null
+++ b/prometheus/alert.rules.yml
@@ -0,0 +1,11 @@
+groups:
+ - name: ecommerce-alerts
+ rules:
+ - alert: HighErrorRate
+ expr: rate(http_server_requests_seconds_count{status="500"}[5m]) > 5
+ for: 1m
+ labels:
+ severity: critical
+ annotations:
+ summary: "High error rate detected"
+ description: "More than 5 errors 500 per minute detected in the last 5 minutes."
diff --git a/prometheus/alertmanager.yml b/prometheus/alertmanager.yml
new file mode 100644
index 000000000..31c331523
--- /dev/null
+++ b/prometheus/alertmanager.yml
@@ -0,0 +1,49 @@
+global:
+ resolve_timeout: 5m
+
+route:
+ group_by: ['alertname', 'cluster', 'service']
+ group_wait: 10s
+ group_interval: 10s
+ repeat_interval: 12h
+ receiver: 'default'
+ routes:
+ - match:
+ severity: critical
+ receiver: 'critical'
+ continue: false
+ - match:
+ severity: warning
+ receiver: 'warning'
+ continue: false
+
+receivers:
+ - name: 'default'
+ webhook_configs:
+ - url: 'http://localhost:5001/alerts'
+ send_resolved: true
+
+ - name: 'critical'
+ webhook_configs:
+ - url: 'http://localhost:5001/alerts/critical'
+ send_resolved: true
+ # Descomentar y configurar para usar email
+ # email_configs:
+ # - to: 'team@example.com'
+ # from: 'alertmanager@example.com'
+ # smarthost: 'smtp.example.com:587'
+ # auth_username: 'alertmanager@example.com'
+ # auth_password: 'password'
+
+ - name: 'warning'
+ webhook_configs:
+ - url: 'http://localhost:5001/alerts/warning'
+ send_resolved: true
+
+inhibit_rules:
+ # Inhibit warning alerts when critical alerts are firing
+ - source_match:
+ severity: 'critical'
+ target_match:
+ severity: 'warning'
+ equal: ['alertname', 'cluster', 'service']
diff --git a/prometheus/prometheus-lite.yml b/prometheus/prometheus-lite.yml
new file mode 100644
index 000000000..f4d898c5c
--- /dev/null
+++ b/prometheus/prometheus-lite.yml
@@ -0,0 +1,27 @@
+global:
+ scrape_interval: 15s
+ evaluation_interval: 15s
+ external_labels:
+ cluster: 'ecommerce-dev'
+ environment: 'development'
+
+alerting:
+ alertmanagers:
+ - static_configs:
+ - targets: ['alertmanager:9093']
+
+rule_files:
+ - '/etc/prometheus/alert.rules.yml'
+
+scrape_configs:
+ # Solo los 3 microservicios que están corriendo
+ - job_name: 'ecommerce-services'
+ metrics_path: '/actuator/prometheus'
+ scrape_interval: 10s
+ static_configs:
+ - targets:
+ - 'ecommerce-microservice-backend-app-product-service-container-1:8500'
+ - 'ecommerce-microservice-backend-app-order-service-container-1:8300'
+ - 'ecommerce-microservice-backend-app-payment-service-container-1:8400'
+ labels:
+ environment: 'dev'
diff --git a/prometheus/prometheus.yml b/prometheus/prometheus.yml
new file mode 100644
index 000000000..847198523
--- /dev/null
+++ b/prometheus/prometheus.yml
@@ -0,0 +1,48 @@
+global:
+ scrape_interval: 15s
+ evaluation_interval: 15s
+ external_labels:
+ cluster: 'ecommerce-dev'
+ environment: 'development'
+
+alerting:
+ alertmanagers:
+ - static_configs:
+ - targets: ['alertmanager:9093']
+
+rule_files:
+ - '/etc/prometheus/alert.rules.yml'
+
+scrape_configs:
+ # Product Service
+ - job_name: 'product-service'
+ metrics_path: '/product-service/actuator/prometheus'
+ scrape_interval: 10s
+ static_configs:
+ - targets:
+ - 'ecommerce-microservice-backend-app-product-service-container-1:8500'
+ labels:
+ application: 'product-service'
+ environment: 'dev'
+
+ # Order Service
+ - job_name: 'order-service'
+ metrics_path: '/order-service/actuator/prometheus'
+ scrape_interval: 10s
+ static_configs:
+ - targets:
+ - 'ecommerce-microservice-backend-app-order-service-container-1:8300'
+ labels:
+ application: 'order-service'
+ environment: 'dev'
+
+ # Payment Service
+ - job_name: 'payment-service'
+ metrics_path: '/payment-service/actuator/prometheus'
+ scrape_interval: 10s
+ static_configs:
+ - targets:
+ - 'ecommerce-microservice-backend-app-payment-service-container-1:8400'
+ labels:
+ application: 'payment-service'
+ environment: 'dev'
diff --git a/proxy-client/Dockerfile b/proxy-client/Dockerfile
index deac97bb7..eba6f7477 100644
--- a/proxy-client/Dockerfile
+++ b/proxy-client/Dockerfile
@@ -1,12 +1,9 @@
-
FROM openjdk:11
ARG PROJECT_VERSION=0.1.0
RUN mkdir -p /home/app
WORKDIR /home/app
-ENV SPRING_PROFILES_ACTIVE dev
+ENV SPRING_PROFILES_ACTIVE=dev
COPY proxy-client/ .
ADD proxy-client/target/proxy-client-v${PROJECT_VERSION}.jar proxy-client.jar
EXPOSE 8900
-ENTRYPOINT ["java", "-Dspring.profiles.active=${SPRING_PROFILES_ACTIVE}", "-jar", "proxy-client.jar"]
-
-
+ENTRYPOINT ["java", "-Dspring.profiles.active=${SPRING_PROFILES_ACTIVE}", "-jar", "proxy-client.jar"]
\ No newline at end of file
diff --git a/proxy-client/compose.yml b/proxy-client/compose.yml
index 6255f4c12..692c62ccf 100644
--- a/proxy-client/compose.yml
+++ b/proxy-client/compose.yml
@@ -1,12 +1,23 @@
-
version: '3'
services:
auth-service-container:
- image: selimhorri/proxy-client-ecommerce-boot:0.1.0
+ image: juanse201/proxy-client-ecommerce-boot:0.1.0
ports:
- 8900:8900
environment:
- SPRING_PROFILES_ACTIVE=dev
+ - SPRING_ZIPKIN_BASE_URL=http://zipkin:9411
+ - SPRING_CONFIG_IMPORT=optional:configserver:http://cloud-config-container:9296/
+ - EUREKA_CLIENT_REGION=default
+ - EUREKA_CLIENT_AVAILABILITY_ZONES_DEFAULT=myzone
+ - EUREKA_CLIENT_SERVICEURL_MYZONE=http://service-discovery-container:8761/eureka
+ - EUREKA_CLIENT_SERVICEURL_DEFAULTZONE=http://service-discovery-container:8761/eureka/
+ networks:
+ - microservices_network
+networks:
+ microservices_network:
+ external: true
+ name: microservices_network
diff --git a/proxy-client/pom.xml b/proxy-client/pom.xml
index 16a9917f3..e83075153 100644
--- a/proxy-client/pom.xml
+++ b/proxy-client/pom.xml
@@ -72,6 +72,28 @@
spring-security-test
test
+
+ org.testcontainers
+ mysql
+ test
+
+
+ org.springframework.boot
+ spring-boot-starter-actuator
+
+
+ io.micrometer
+ micrometer-registry-prometheus
+
+
+ net.logstash.logback
+ logstash-logback-encoder
+ 7.3
+
+
+ org.springframework.cloud
+ spring-cloud-starter-sleuth
+
diff --git a/proxy-client/src/main/resources/application.yml b/proxy-client/src/main/resources/application.yml
index 3869e3030..c2aa962f6 100644
--- a/proxy-client/src/main/resources/application.yml
+++ b/proxy-client/src/main/resources/application.yml
@@ -5,15 +5,20 @@ server:
spring:
zipkin:
- base-url: ${SPRING_ZIPKIN_BASE_URL:http://localhost:9411/}
+ base-url: ${SPRING_ZIPKIN_BASE_URL:http://zipkin:9411/}
config:
- import: ${SPRING_CONFIG_IMPORT:optional:configserver:http://localhost:9296}
+ import: ${SPRING_CONFIG_IMPORT:optional:configserver:http://cloud-config-container:9296}
application:
name: PROXY-CLIENT
profiles:
active:
- dev
+eureka:
+ client:
+ service-url:
+ defaultZone: ${EUREKA_CLIENT_SERVICEURL_DEFAULTZONE:http://service-discovery-container:8761/eureka/}
+
resilience4j:
circuitbreaker:
instances:
@@ -29,12 +34,33 @@ resilience4j:
sliding-window-type: COUNT_BASED
management:
- health:
- circuitbreakers:
- enabled: true
+ endpoints:
+ web:
+ exposure:
+ include: health,info,metrics,prometheus,env,loggers,threaddump,heapdump
endpoint:
health:
show-details: always
+ probes:
+ enabled: true
+ metrics:
+ enabled: true
+ prometheus:
+ enabled: true
+ metrics:
+ export:
+ prometheus:
+ enabled: true
+ tags:
+ application: ${spring.application.name}
+ environment: ${spring.profiles.active}
+ health:
+ circuitbreakers:
+ enabled: true
+ livenessstate:
+ enabled: true
+ readinessstate:
+ enabled: true
diff --git a/proxy-client/src/main/resources/logback-spring.xml b/proxy-client/src/main/resources/logback-spring.xml
new file mode 100644
index 000000000..9a551a487
--- /dev/null
+++ b/proxy-client/src/main/resources/logback-spring.xml
@@ -0,0 +1,46 @@
+
+
+
+
+
+
+
+
+
+
+ {"app_name":"${appName}","app_port":"${appPort}"}
+ traceId
+ spanId
+
+
+
+
+
+ logstash:5000
+
+ {"app_name":"${appName}","app_port":"${appPort}"}
+ traceId
+ spanId
+
+ 5 minutes
+
+
+
+
+
+ 512
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/proxy-client/src/test/java/com/selimhorri/app/integration/EncoderConfigIntegrationTest.java b/proxy-client/src/test/java/com/selimhorri/app/integration/EncoderConfigIntegrationTest.java
new file mode 100644
index 000000000..f5526bb6c
--- /dev/null
+++ b/proxy-client/src/test/java/com/selimhorri/app/integration/EncoderConfigIntegrationTest.java
@@ -0,0 +1,18 @@
+package com.selimhorri.app.integration;
+
+import com.selimhorri.app.config.encoder.EncoderConfig;
+import org.junit.jupiter.api.Test;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class EncoderConfigIntegrationTest {
+
+ @Test
+ void testPasswordEncoderBeanMatches() {
+ EncoderConfig config = new EncoderConfig();
+ PasswordEncoder encoder = config.getPasswordEncoder();
+ String raw = "integrationPass";
+ String encoded = encoder.encode(raw);
+ assertTrue(encoder.matches(raw, encoded));
+ }
+}
diff --git a/proxy-client/src/test/java/com/selimhorri/app/integration/JwtUtilImplIntegrationTest.java b/proxy-client/src/test/java/com/selimhorri/app/integration/JwtUtilImplIntegrationTest.java
new file mode 100644
index 000000000..30083c856
--- /dev/null
+++ b/proxy-client/src/test/java/com/selimhorri/app/integration/JwtUtilImplIntegrationTest.java
@@ -0,0 +1,80 @@
+package com.selimhorri.app.integration;
+
+import com.selimhorri.app.jwt.util.impl.JwtUtilImpl;
+import org.junit.jupiter.api.Test;
+import org.springframework.security.core.userdetails.UserDetails;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class JwtUtilImplIntegrationTest {
+
+ // Dummy UserDetails for testing
+ static class DummyUserDetails implements org.springframework.security.core.userdetails.UserDetails {
+ private final String username;
+ DummyUserDetails(String username) { this.username = username; }
+ @Override public String getUsername() { return username; }
+ @Override public String getPassword() { return "pass"; }
+ @Override public boolean isAccountNonExpired() { return true; }
+ @Override public boolean isAccountNonLocked() { return true; }
+ @Override public boolean isCredentialsNonExpired() { return true; }
+ @Override public boolean isEnabled() { return true; }
+ @Override public java.util.Collection getAuthorities() { return java.util.Collections.emptyList(); }
+ }
+
+ @Test
+ void testTokenLifecycle() {
+ JwtUtilImpl jwtUtil = new JwtUtilImpl();
+ UserDetails user = new DummyUserDetails("integrationUser");
+ String token = jwtUtil.generateToken(user);
+ assertNotNull(token);
+ assertEquals("integrationUser", jwtUtil.extractUsername(token));
+ assertTrue(jwtUtil.validateToken(token, user));
+ }
+
+ @Test
+ void testTokenInvalidForOtherUser() {
+ JwtUtilImpl jwtUtil = new JwtUtilImpl();
+ UserDetails user = new DummyUserDetails("integrationUser");
+ String token = jwtUtil.generateToken(user);
+ UserDetails other = new DummyUserDetails("otherUser");
+ assertFalse(jwtUtil.validateToken(token, other));
+ }
+
+ @Test
+ void testTokenExpiration() throws InterruptedException {
+ JwtUtilImpl jwtUtil = new JwtUtilImpl() {
+ @Override
+ public String generateToken(UserDetails userDetails) {
+ // Override to set short expiration for test
+ java.util.Map claims = new java.util.HashMap<>();
+ return io.jsonwebtoken.Jwts.builder()
+ .setClaims(claims)
+ .setSubject(userDetails.getUsername())
+ .setIssuedAt(new java.util.Date(System.currentTimeMillis()))
+ .setExpiration(new java.util.Date(System.currentTimeMillis() + 100))
+ .signWith(io.jsonwebtoken.SignatureAlgorithm.HS256, "secret")
+ .compact();
+ }
+ };
+ UserDetails user = new DummyUserDetails("expUser");
+ String token = jwtUtil.generateToken(user);
+ Thread.sleep(150); // Wait for expiration
+ assertThrows(io.jsonwebtoken.ExpiredJwtException.class, () -> jwtUtil.validateToken(token, user));
+ }
+
+ @Test
+ void testExtractClaims() {
+ JwtUtilImpl jwtUtil = new JwtUtilImpl();
+ UserDetails user = new DummyUserDetails("claimsUser");
+ String token = jwtUtil.generateToken(user);
+ String subject = jwtUtil.extractClaims(token, claims -> claims.getSubject());
+ assertEquals("claimsUser", subject);
+ }
+
+ @Test
+ void testExtractExpirationNotNull() {
+ JwtUtilImpl jwtUtil = new JwtUtilImpl();
+ UserDetails user = new DummyUserDetails("expUser");
+ String token = jwtUtil.generateToken(user);
+ assertNotNull(jwtUtil.extractExpiration(token));
+ }
+}
diff --git a/proxy-client/src/test/java/com/selimhorri/app/integration/UserControllerIntegrationTest.java b/proxy-client/src/test/java/com/selimhorri/app/integration/UserControllerIntegrationTest.java
new file mode 100644
index 000000000..9060d5fe5
--- /dev/null
+++ b/proxy-client/src/test/java/com/selimhorri/app/integration/UserControllerIntegrationTest.java
@@ -0,0 +1,69 @@
+package com.selimhorri.app.integration;
+
+import com.selimhorri.app.business.user.controller.UserController;
+import com.selimhorri.app.business.user.model.UserDto;
+import com.selimhorri.app.business.user.model.CredentialDto;
+import com.selimhorri.app.business.user.service.UserClientService;
+import com.selimhorri.app.business.user.model.response.UserUserServiceCollectionDtoResponse;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+import org.springframework.http.ResponseEntity;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class UserControllerIntegrationTest {
+
+ @Test
+ void testFindAllReturnsCollection() {
+ UserClientService mockService = Mockito.mock(UserClientService.class);
+ UserUserServiceCollectionDtoResponse response = new UserUserServiceCollectionDtoResponse();
+ Mockito.when(mockService.findAll()).thenReturn(ResponseEntity.ok(response));
+ UserController controller = new UserController(mockService);
+ ResponseEntity result = controller.findAll();
+ assertEquals(response, result.getBody());
+ }
+
+ @Test
+ void testFindByIdReturnsUser() {
+ UserClientService mockService = Mockito.mock(UserClientService.class);
+ UserDto user = new UserDto(); user.setUserId(1);
+ Mockito.when(mockService.findById("1")).thenReturn(ResponseEntity.ok(user));
+ UserController controller = new UserController(mockService);
+ ResponseEntity result = controller.findById("1");
+ assertEquals(user, result.getBody());
+ }
+
+ @Test
+ void testFindByUsernameReturnsUser() {
+ UserClientService mockService = Mockito.mock(UserClientService.class);
+ UserDto user = new UserDto();
+ CredentialDto cred = new CredentialDto();
+ cred.setUsername("testuser");
+ user.setCredentialDto(cred);
+ Mockito.when(mockService.findByUsername("testuser")).thenReturn(ResponseEntity.ok(user));
+ UserController controller = new UserController(mockService);
+ ResponseEntity result = controller.findByUsername("testuser");
+ assertEquals(user, result.getBody());
+ }
+
+ @Test
+ void testSaveReturnsSavedUser() {
+ UserClientService mockService = Mockito.mock(UserClientService.class);
+ UserDto user = new UserDto();
+ CredentialDto cred = new CredentialDto();
+ cred.setUsername("saveuser");
+ user.setCredentialDto(cred);
+ Mockito.when(mockService.save(user)).thenReturn(ResponseEntity.ok(user));
+ UserController controller = new UserController(mockService);
+ ResponseEntity result = controller.save(user);
+ assertEquals(user, result.getBody());
+ }
+
+ @Test
+ void testDeleteByIdReturnsTrue() {
+ UserClientService mockService = Mockito.mock(UserClientService.class);
+ Mockito.when(mockService.deleteById("1")).thenReturn(ResponseEntity.ok(true));
+ UserController controller = new UserController(mockService);
+ ResponseEntity result = controller.deleteById("1");
+ assertTrue(result.getBody());
+ }
+}
diff --git a/proxy-client/src/test/java/com/selimhorri/app/integration/UserDetailsImplIntegrationTest.java b/proxy-client/src/test/java/com/selimhorri/app/integration/UserDetailsImplIntegrationTest.java
new file mode 100644
index 000000000..3757eaa2b
--- /dev/null
+++ b/proxy-client/src/test/java/com/selimhorri/app/integration/UserDetailsImplIntegrationTest.java
@@ -0,0 +1,91 @@
+package com.selimhorri.app.integration;
+
+import com.selimhorri.app.business.user.model.CredentialDto;
+import com.selimhorri.app.business.user.model.RoleBasedAuthority;
+import com.selimhorri.app.business.user.model.UserDetailsImpl;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class UserDetailsImplIntegrationTest {
+
+ @Test
+ void testUserDetailsImplWithCredential() {
+ CredentialDto credential = CredentialDto.builder()
+ .username("integrationUser")
+ .password("integrationPass")
+ .roleBasedAuthority(RoleBasedAuthority.ROLE_USER)
+ .isEnabled(true)
+ .isAccountNonExpired(true)
+ .isAccountNonLocked(true)
+ .isCredentialsNonExpired(true)
+ .build();
+ UserDetailsImpl userDetails = new UserDetailsImpl(credential);
+ assertEquals("integrationUser", userDetails.getUsername());
+ assertEquals("integrationPass", userDetails.getPassword());
+ assertTrue(userDetails.isEnabled());
+ assertTrue(userDetails.isAccountNonExpired());
+ assertTrue(userDetails.isAccountNonLocked());
+ assertTrue(userDetails.isCredentialsNonExpired());
+ assertEquals("ROLE_USER", userDetails.getAuthorities().iterator().next().getAuthority());
+ }
+
+ @Test
+ void testUserDetailsImplDisabled() {
+ CredentialDto credential = CredentialDto.builder()
+ .username("disabledUser")
+ .password("pass")
+ .roleBasedAuthority(RoleBasedAuthority.ROLE_USER)
+ .isEnabled(false)
+ .isAccountNonExpired(true)
+ .isAccountNonLocked(true)
+ .isCredentialsNonExpired(true)
+ .build();
+ UserDetailsImpl userDetails = new UserDetailsImpl(credential);
+ assertFalse(userDetails.isEnabled());
+ }
+
+ @Test
+ void testUserDetailsImplAccountExpired() {
+ CredentialDto credential = CredentialDto.builder()
+ .username("expiredUser")
+ .password("pass")
+ .roleBasedAuthority(RoleBasedAuthority.ROLE_USER)
+ .isEnabled(true)
+ .isAccountNonExpired(false)
+ .isAccountNonLocked(true)
+ .isCredentialsNonExpired(true)
+ .build();
+ UserDetailsImpl userDetails = new UserDetailsImpl(credential);
+ assertFalse(userDetails.isAccountNonExpired());
+ }
+
+ @Test
+ void testUserDetailsImplAccountLocked() {
+ CredentialDto credential = CredentialDto.builder()
+ .username("lockedUser")
+ .password("pass")
+ .roleBasedAuthority(RoleBasedAuthority.ROLE_USER)
+ .isEnabled(true)
+ .isAccountNonExpired(true)
+ .isAccountNonLocked(false)
+ .isCredentialsNonExpired(true)
+ .build();
+ UserDetailsImpl userDetails = new UserDetailsImpl(credential);
+ assertFalse(userDetails.isAccountNonLocked());
+ }
+
+ @Test
+ void testUserDetailsImplCredentialsExpired() {
+ CredentialDto credential = CredentialDto.builder()
+ .username("credExpiredUser")
+ .password("pass")
+ .roleBasedAuthority(RoleBasedAuthority.ROLE_USER)
+ .isEnabled(true)
+ .isAccountNonExpired(true)
+ .isAccountNonLocked(true)
+ .isCredentialsNonExpired(false)
+ .build();
+ UserDetailsImpl userDetails = new UserDetailsImpl(credential);
+ assertFalse(userDetails.isCredentialsNonExpired());
+ }
+}
diff --git a/proxy-client/src/test/java/com/selimhorri/app/unit/EncoderConfigUnitTest.java b/proxy-client/src/test/java/com/selimhorri/app/unit/EncoderConfigUnitTest.java
new file mode 100644
index 000000000..7cfe7f819
--- /dev/null
+++ b/proxy-client/src/test/java/com/selimhorri/app/unit/EncoderConfigUnitTest.java
@@ -0,0 +1,19 @@
+package com.selimhorri.app.unit;
+
+import com.selimhorri.app.config.encoder.EncoderConfig;
+import org.junit.jupiter.api.Test;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class EncoderConfigUnitTest {
+
+ @Test
+ void testPasswordEncoderBeanIsBCrypt() {
+ EncoderConfig config = new EncoderConfig();
+ PasswordEncoder encoder = config.getPasswordEncoder();
+ assertNotNull(encoder);
+ String raw = "password123";
+ String encoded = encoder.encode(raw);
+ assertTrue(encoder.matches(raw, encoded));
+ }
+}
diff --git a/proxy-client/src/test/java/com/selimhorri/app/unit/JwtUtilImplUnitTest.java b/proxy-client/src/test/java/com/selimhorri/app/unit/JwtUtilImplUnitTest.java
new file mode 100644
index 000000000..a88631fc3
--- /dev/null
+++ b/proxy-client/src/test/java/com/selimhorri/app/unit/JwtUtilImplUnitTest.java
@@ -0,0 +1,62 @@
+package com.selimhorri.app.unit;
+
+import com.selimhorri.app.jwt.util.impl.JwtUtilImpl;
+import org.junit.jupiter.api.Test;
+import org.springframework.security.core.userdetails.UserDetails;
+import java.util.Date;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class JwtUtilImplUnitTest {
+
+ @Test
+ void testExtractUsername() {
+ JwtUtilImpl jwtUtil = new JwtUtilImpl();
+ String token = jwtUtil.generateToken(new DummyUserDetails("user1"));
+ assertEquals("user1", jwtUtil.extractUsername(token));
+ }
+
+ @Test
+ void testExtractExpiration() {
+ JwtUtilImpl jwtUtil = new JwtUtilImpl();
+ String token = jwtUtil.generateToken(new DummyUserDetails("user1"));
+ Date expiration = jwtUtil.extractExpiration(token);
+ assertTrue(expiration.after(new Date()));
+ }
+
+ @Test
+ void testGenerateTokenNotNull() {
+ JwtUtilImpl jwtUtil = new JwtUtilImpl();
+ String token = jwtUtil.generateToken(new DummyUserDetails("user1"));
+ assertNotNull(token);
+ }
+
+ @Test
+ void testValidateTokenTrue() {
+ JwtUtilImpl jwtUtil = new JwtUtilImpl();
+ UserDetails user = new DummyUserDetails("user1");
+ String token = jwtUtil.generateToken(user);
+ assertTrue(jwtUtil.validateToken(token, user));
+ }
+
+ @Test
+ void testValidateTokenFalseForWrongUser() {
+ JwtUtilImpl jwtUtil = new JwtUtilImpl();
+ UserDetails user = new DummyUserDetails("user1");
+ String token = jwtUtil.generateToken(user);
+ UserDetails otherUser = new DummyUserDetails("user2");
+ assertFalse(jwtUtil.validateToken(token, otherUser));
+ }
+
+ // Dummy UserDetails for testing
+ static class DummyUserDetails implements UserDetails {
+ private final String username;
+ DummyUserDetails(String username) { this.username = username; }
+ @Override public String getUsername() { return username; }
+ @Override public String getPassword() { return "pass"; }
+ @Override public boolean isAccountNonExpired() { return true; }
+ @Override public boolean isAccountNonLocked() { return true; }
+ @Override public boolean isCredentialsNonExpired() { return true; }
+ @Override public boolean isEnabled() { return true; }
+ @Override public java.util.Collection getAuthorities() { return java.util.Collections.emptyList(); }
+ }
+}
diff --git a/proxy-client/src/test/java/com/selimhorri/app/unit/UserDetailsImplUnitTest.java b/proxy-client/src/test/java/com/selimhorri/app/unit/UserDetailsImplUnitTest.java
new file mode 100644
index 000000000..da3a86e8a
--- /dev/null
+++ b/proxy-client/src/test/java/com/selimhorri/app/unit/UserDetailsImplUnitTest.java
@@ -0,0 +1,67 @@
+package com.selimhorri.app.unit;
+
+import com.selimhorri.app.business.user.model.UserDetailsImpl;
+import com.selimhorri.app.business.user.model.CredentialDto;
+import org.junit.jupiter.api.Test;
+import org.springframework.security.core.GrantedAuthority;
+import java.util.Collection;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class UserDetailsImplUnitTest {
+
+ @Test
+ void testGetUsername() {
+ CredentialDto credential = getCredential("user1", "pass", "ROLE_USER");
+ UserDetailsImpl userDetails = new UserDetailsImpl(credential);
+ assertEquals("user1", userDetails.getUsername());
+ }
+
+ @Test
+ void testGetPassword() {
+ CredentialDto credential = getCredential("user1", "pass123", "ROLE_USER");
+ UserDetailsImpl userDetails = new UserDetailsImpl(credential);
+ assertEquals("pass123", userDetails.getPassword());
+ }
+
+ @Test
+ void testIsEnabled() {
+ CredentialDto credential = getCredential("user1", "pass", "ROLE_USER");
+ credential.setIsEnabled(true);
+ UserDetailsImpl userDetails = new UserDetailsImpl(credential);
+ assertTrue(userDetails.isEnabled());
+ }
+
+ @Test
+ void testGetAuthorities() {
+ CredentialDto credential = getCredential("user1", "pass", "ROLE_ADMIN");
+ UserDetailsImpl userDetails = new UserDetailsImpl(credential);
+ Collection authorities = userDetails.getAuthorities();
+ assertEquals(1, authorities.size());
+ assertEquals("ROLE_ADMIN", authorities.iterator().next().getAuthority());
+ }
+
+ @Test
+ void testAccountNonExpiredAndLocked() {
+ CredentialDto credential = getCredential("user1", "pass", "ROLE_USER");
+ credential.setIsAccountNonExpired(true);
+ credential.setIsAccountNonLocked(true);
+ credential.setIsCredentialsNonExpired(true);
+ UserDetailsImpl userDetails = new UserDetailsImpl(credential);
+ assertTrue(userDetails.isAccountNonExpired());
+ assertTrue(userDetails.isAccountNonLocked());
+ assertTrue(userDetails.isCredentialsNonExpired());
+ }
+
+ // Helper to create a CredentialDto with default values
+ private CredentialDto getCredential(String username, String password, String role) {
+ CredentialDto credential = new CredentialDto();
+ credential.setUsername(username);
+ credential.setPassword(password);
+ credential.setRoleBasedAuthority(com.selimhorri.app.business.user.model.RoleBasedAuthority.valueOf(role));
+ credential.setIsEnabled(true);
+ credential.setIsAccountNonExpired(true);
+ credential.setIsAccountNonLocked(true);
+ credential.setIsCredentialsNonExpired(true);
+ return credential;
+ }
+}
diff --git a/release-notes/README.md b/release-notes/README.md
new file mode 100644
index 000000000..71efcb2fd
--- /dev/null
+++ b/release-notes/README.md
@@ -0,0 +1,228 @@
+# Release Notes Generator
+
+Script automatizado para generar release notes en deployments de producción y staging con **versionado automático**.
+
+## Descripción
+
+Este script genera automáticamente documentación de release notes que incluye:
+- Información de versión y fecha
+- Lista de servicios desplegados
+- Commits recientes
+- Detalles de infraestructura
+- Enlaces a builds de Jenkins y commits de GitHub
+
+## Uso
+
+### Sintaxis Básica
+```bash
+./generate-release-notes.sh [version] [environment] [service1] [service2] ...
+```
+
+### Auto-detección de Versión
+
+El script ahora detecta automáticamente la versión si no se especifica:
+
+**Prioridad de detección:**
+1. Variable `BUILD_NUMBER` (Jenkins)
+2. Último tag de Git (ej: `v1.2.3`)
+3. Número de commits (ej: `0.0.152`)
+4. Timestamp (fallback)
+
+### Ejemplos
+
+**Con auto-detección de versión:**
+```bash
+# Detecta versión automáticamente, ambiente por defecto (production)
+./release-notes/generate-release-notes.sh
+
+# Solo especifica ambiente, versión auto-detectada
+./release-notes/generate-release-notes.sh production
+
+# Ambiente + servicios, versión auto-detectada
+./release-notes/generate-release-notes.sh staging order-service user-service
+```
+
+**Con versión manual:**
+```bash
+# Versión específica
+./release-notes/generate-release-notes.sh "1.0.0" "production"
+
+# Versión + servicios
+./release-notes/generate-release-notes.sh "2.5.0" "production" \
+ order-service user-service payment-service
+```
+
+**Desde Jenkins (Production):**
+```bash
+# Simple - usa BUILD_NUMBER automáticamente
+./release-notes/generate-release-notes.sh production \
+ order-service user-service payment-service
+
+# O incluso más simple - todo se auto-detecta
+./release-notes/generate-release-notes.sh
+```
+
+**Desde Jenkins (Staging):**
+```bash
+./release-notes/generate-release-notes.sh staging \
+ order-service user-service payment-service
+```
+
+**Manual:**
+```bash
+./release-notes/generate-release-notes.sh "1.0.0" "production" \
+ "service1" "service2"
+```
+
+## Gestión de Versiones con Git Tags
+
+### Version Manager Script
+
+Incluye un script adicional para gestionar versiones semánticas automáticamente:
+
+```bash
+./release-notes/version-manager.sh [major|minor|patch|auto]
+```
+
+**Tipos de versión:**
+- `major`: 1.0.0 → 2.0.0 (cambios incompatibles)
+- `minor`: 1.0.0 → 1.1.0 (nuevas features)
+- `patch`: 1.0.0 → 1.0.1 (bug fixes)
+- `auto`: Analiza commits y decide automáticamente
+
+**Análisis automático de commits (Conventional Commits):**
+- `feat:` → incrementa **minor**
+- `fix:` → incrementa **patch**
+- `BREAKING CHANGE` o `!:` → incrementa **major**
+
+**Ejemplo de uso:**
+```bash
+# Auto-detectar tipo de versión según commits
+./release-notes/version-manager.sh auto
+
+# Incrementar versión minor manualmente
+./release-notes/version-manager.sh minor
+
+# Esto creará el tag y opcionalmente las release notes
+```
+
+### Workflow Recomendado
+
+```bash
+# 1. Hacer commits con Conventional Commits
+git commit -m "feat: add new payment method"
+git commit -m "fix: resolve memory leak"
+
+# 2. Cuando estés listo para release
+./release-notes/version-manager.sh auto
+
+# 3. El script:
+# - Analiza commits
+# - Sugiere nueva versión
+# - Crea el tag
+# - Opcionalmente genera release notes
+
+# 4. Push del tag
+git push origin v1.2.0
+```
+
+## Estructura de Archivos
+
+Los release notes se guardan en:
+```
+release-notes/
+├── generate-release-notes.sh # Script principal
+├── README.md # Esta documentación
+├── RELEASE-production-v1.md # Release notes de producción
+├── RELEASE-staging-v2.md # Release notes de staging
+└── ...
+```
+
+## Integración con Jenkins
+
+### En Jenkinsfile
+```groovy
+stage('Generate Release Notes') {
+ steps {
+ sh """
+ chmod +x release-notes/generate-release-notes.sh
+ ./release-notes/generate-release-notes.sh \
+ "${BUILD_NUMBER}" \
+ "production" \
+ "${S1}" "${S2}" "${S3}" "${S4}" \
+ "${S5}" "${S6}" "${S7}" "${S8}"
+ """
+ archiveArtifacts artifacts: "release-notes/RELEASE-*.md", fingerprint: true
+ }
+}
+```
+
+## Formato de Release Notes
+
+El script genera un archivo Markdown con las siguientes secciones:
+
+1. **Información General**: Versión, fecha, commit, build
+2. **Servicios Desplegados**: Lista de microservicios
+3. **Imágenes Docker**: Información del registry
+4. **Últimos Cambios**: Top 10 commits
+5. **Infraestructura**: Detalles de K8s y CI/CD
+6. **Estado del Deployment**: Checklist de validaciones
+7. **Validaciones**: Tests y health checks
+8. **Notas Adicionales**: Enlaces útiles
+
+## Variables de Entorno
+
+El script utiliza automáticamente las siguientes variables si están disponibles:
+
+| Variable | Descripción | Default |
+|----------|-------------|---------|
+| `BUILD_NUMBER` | Número de build de Jenkins | "N/A" |
+| `JOB_NAME` | Nombre del job de Jenkins | "Manual" |
+| `BUILD_URL` | URL del build en Jenkins | "N/A" |
+
+## Características
+
+- Detecta automáticamente si las release notes ya existen
+- Obtiene información de Git (hash, branch, commits)
+- Integración automática con Jenkins
+- Output colorizado para mejor legibilidad
+- Manejo de errores robusto
+- Compatible con diferentes ambientes
+
+## Comportamiento
+
+### Si las Release Notes YA existen:
+- Muestra un warning
+- Imprime el contenido existente
+- Sale con código 0 (éxito)
+
+### Si NO existen:
+- Crea el archivo nuevo
+- Imprime el contenido generado
+- Sale con código 0 (éxito)
+
+## Notas
+
+- El script es idempotente: ejecutarlo múltiples veces no sobrescribe archivos existentes
+- Requiere Git para obtener información de commits
+- Compatible con bash en Linux/Unix y Git Bash en Windows
+- Los archivos generados usan formato Markdown estándar
+
+## Troubleshooting
+
+**Error: "Permission denied"**
+```bash
+chmod +x release-notes/generate-release-notes.sh
+```
+
+**Error: "git: command not found"**
+- Asegúrate de que Git esté instalado y en el PATH
+- El script continuará con valores por defecto si Git no está disponible
+
+**Los colores no se muestran correctamente**
+- Normal en algunos entornos de Jenkins
+- No afecta la funcionalidad del script
+
+## Licencia
+
+Este script es parte del proyecto ecommerce-microservice-backend-app.
diff --git a/release-notes/RELEASE-EXAMPLE.md b/release-notes/RELEASE-EXAMPLE.md
new file mode 100644
index 000000000..6aa845906
--- /dev/null
+++ b/release-notes/RELEASE-EXAMPLE.md
@@ -0,0 +1,65 @@
+# Release Notes - Production v42
+
+## Información General
+- **Fecha de Release**: 2025-11-03 14:30:00
+- **Versión**: v42
+- **Entorno**: production
+- **Build Number**: 42
+- **Commit Hash**: `a1b2c3d`
+- **Branch**: `master`
+- **Jenkins Job**: ecommerce-production-pipeline
+- **Build URL**: http://jenkins.example.com/job/ecommerce/42
+
+## Servicios Desplegados
+- order-service
+- user-service
+- payment-service
+- product-service
+- favourite-service
+- cloud-config
+- service-discovery
+- zipkin
+
+## Imágenes Docker
+Todas las imágenes fueron desplegadas desde Docker Hub con el tag correspondiente al ambiente production.
+
+## Últimos Cambios (Top 10 Commits)
+- feat: Add new payment gateway integration (Juan Pérez)
+- fix: Resolve memory leak in order service (María García)
+- chore: Update dependencies to latest versions (Carlos López)
+- docs: Update API documentation (Ana Martínez)
+- refactor: Improve database connection pooling (Luis Rodríguez)
+- test: Add integration tests for user service (Pedro Sánchez)
+- feat: Implement caching layer for product catalog (Laura Torres)
+- fix: Correct timezone handling in order timestamps (Miguel Díaz)
+- perf: Optimize database queries in product search (Sofia Ruiz)
+- ci: Improve Jenkins pipeline performance (Juan Pérez)
+
+## Infraestructura
+- **Namespace Kubernetes**: production
+- **Orchestrator**: Kubernetes
+- **Container Registry**: Docker Hub
+- **CI/CD**: Jenkins
+
+## Estado del Deployment
+- Pre-cleanup ejecutado
+- Imágenes Docker verificadas
+- Manifiestos Kubernetes aplicados
+- Servicios y Pods verificados
+- Health checks completados
+
+## Validaciones
+- Build exitoso en Jenkins
+- Tests unitarios
+- Tests de integración
+- Deployment verificado
+
+## Notas Adicionales
+Este release fue generado automáticamente por el pipeline de Jenkins.
+
+### Enlaces Útiles
+- [Jenkins Build #42](http://jenkins.example.com/job/ecommerce/42)
+- [GitHub Commit](https://github.com/JuanseDev2001/ecommerce-microservice-backend-app/commit/a1b2c3d)
+
+---
+*Generado automáticamente el 2025-11-03 14:30:00*
diff --git a/release-notes/RELEASE-production-v-0.1.0.md b/release-notes/RELEASE-production-v-0.1.0.md
new file mode 100644
index 000000000..dcdc9ab3c
--- /dev/null
+++ b/release-notes/RELEASE-production-v-0.1.0.md
@@ -0,0 +1,58 @@
+# Release Notes - Production v-0.1.0
+
+## Información General
+- **Fecha de Release**: 2025-11-03 20:36:20
+- **Versión**: v-0.1.0
+- **Entorno**: production
+- **Build Number**: N/A
+- **Commit Hash**: `17e6248`
+- **Branch**: `stage`
+- **Jenkins Job**: Manual
+- **Build URL**: N/A
+
+## Servicios Desplegados
+- No services specified
+
+## Imágenes Docker
+Todas las imágenes fueron desplegadas desde Docker Hub con el tag correspondiente al ambiente production.
+
+## Últimos Cambios (Top 10 Commits)
+- Update validate_performance.py (juanseDev2001)
+- Update validate_performance.py (juanseDev2001)
+- Update validate_performance.py (juanseDev2001)
+- feat: fixed performance test in pipeline (juanseDev2001)
+- Update Jenkinsfile.stage (juanseDev2001)
+- fix: removed -n stage namespace as it is interfering with tests, left it for prod as if it passes this then its ok (juanseDev2001)
+- feat: Performance Tests added and edited Jenkins to install python with locust for tests (juanseDev2001)
+- Update Jenkinsfile.prod (juanseDev2001)
+- Update Jenkins.md (juanseDev2001)
+- fix (juanseDev2001)
+
+## Infraestructura
+- **Namespace Kubernetes**: production
+- **Orchestrator**: Kubernetes
+- **Container Registry**: Docker Hub
+- **CI/CD**: Jenkins
+
+## Estado del Deployment
+- Pre-cleanup ejecutado
+- Imágenes Docker verificadas
+- Manifiestos Kubernetes aplicados
+- Servicios y Pods verificados
+- Health checks completados
+
+## Validaciones
+- Build exitoso en Jenkins
+- Tests unitarios
+- Tests de integración
+- Deployment verificado
+
+## Notas Adicionales
+Este release fue generado automáticamente por el pipeline de Jenkins.
+
+### Enlaces Útiles
+- [Jenkins Build #N/A](N/A)
+- [GitHub Commit](https://github.com/JuanseDev2001/ecommerce-microservice-backend-app/commit/17e6248)
+
+---
+*Generado automáticamente el 2025-11-03 20:36:20*
diff --git a/release-notes/generate-release-notes.sh b/release-notes/generate-release-notes.sh
new file mode 100755
index 000000000..7d011b47f
--- /dev/null
+++ b/release-notes/generate-release-notes.sh
@@ -0,0 +1,162 @@
+#!/bin/bash
+
+# Script para generar Release Notes automáticamente
+# Uso: ./generate-release-notes.sh [version] [environment] [services...]
+# Si no se proporciona version, se auto-detecta desde Git
+
+set -e
+
+# Colores para output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Función para auto-detectar versión
+get_version() {
+ # Prioridad 1: Variable de entorno BUILD_NUMBER (Jenkins)
+ if [ -n "$BUILD_NUMBER" ]; then
+ echo "$BUILD_NUMBER"
+ return
+ fi
+
+ # Prioridad 2: Último tag de Git
+ local git_tag=$(git describe --tags --abbrev=0 2>/dev/null || echo "")
+ if [ -n "$git_tag" ]; then
+ # Remover 'v-' del inicio (mantener formato con guión en archivos)
+ echo "${git_tag#v-}"
+ return
+ fi
+
+ # Prioridad 3: Contar commits desde el inicio
+ local commit_count=$(git rev-list --count HEAD 2>/dev/null || echo "0")
+ if [ "$commit_count" != "0" ]; then
+ echo "0.0.${commit_count}"
+ return
+ fi
+
+ # Fallback: usar timestamp
+ echo "$(date +%Y%m%d-%H%M%S)"
+}
+
+# Parsear argumentos (ahora todos son opcionales)
+if [ $# -eq 0 ]; then
+ # Sin argumentos: auto-detectar todo
+ VERSION=$(get_version)
+ ENVIRONMENT=${ENVIRONMENT:-"production"}
+ SERVICES=()
+elif [ $# -eq 1 ]; then
+ # Solo ambiente o solo versión
+ if [[ "$1" =~ ^(production|staging|prod|stage|dev|development)$ ]]; then
+ VERSION=$(get_version)
+ ENVIRONMENT="$1"
+ SERVICES=()
+ else
+ VERSION="$1"
+ ENVIRONMENT=${ENVIRONMENT:-"production"}
+ SERVICES=()
+ fi
+else
+ # Argumentos completos
+ VERSION=${1:-$(get_version)}
+ ENVIRONMENT=${2:-"production"}
+ shift 2
+ SERVICES=("$@")
+fi
+
+RELEASE_DIR="release-notes"
+RELEASE_FILE="${RELEASE_DIR}/RELEASE-${ENVIRONMENT}-v${VERSION}.md"
+DATE=$(date +%Y-%m-%d)
+TIME=$(date +%H:%M:%S)
+GIT_HASH=$(git rev-parse --short HEAD 2>/dev/null || echo "N/A")
+GIT_BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "N/A")
+GIT_LOG=$(git log --pretty=format:"- %s (%an)" -10 2>/dev/null || echo "No git history available")
+
+# Crear directorio si no existe
+mkdir -p "${RELEASE_DIR}"
+
+# Verificar si el archivo ya existe
+if [ -f "${RELEASE_FILE}" ]; then
+ echo -e "${YELLOW}Release Notes para ${ENVIRONMENT} v${VERSION} ya existen${NC}"
+ echo -e "${BLUE}Archivo: ${RELEASE_FILE}${NC}"
+ cat "${RELEASE_FILE}"
+ exit 0
+fi
+
+echo -e "${GREEN}Generando Release Notes para ${ENVIRONMENT} v${VERSION}...${NC}"
+
+# Generar lista de servicios
+SERVICES_LIST=""
+if [ ${#SERVICES[@]} -gt 0 ]; then
+ for service in "${SERVICES[@]}"; do
+ SERVICES_LIST="${SERVICES_LIST}- ${service}\n"
+ done
+else
+ SERVICES_LIST="- No services specified\n"
+fi
+
+# Obtener información adicional de Jenkins si está disponible
+BUILD_NUMBER=${BUILD_NUMBER:-"N/A"}
+JOB_NAME=${JOB_NAME:-"Manual"}
+BUILD_URL=${BUILD_URL:-"N/A"}
+
+# Crear el archivo de release notes
+cat > "${RELEASE_FILE}" << EOF
+# Release Notes - ${ENVIRONMENT^} v${VERSION}
+
+## Información General
+- **Fecha de Release**: ${DATE} ${TIME}
+- **Versión**: v${VERSION}
+- **Entorno**: ${ENVIRONMENT}
+- **Build Number**: ${BUILD_NUMBER}
+- **Commit Hash**: \`${GIT_HASH}\`
+- **Branch**: \`${GIT_BRANCH}\`
+- **Jenkins Job**: ${JOB_NAME}
+- **Build URL**: ${BUILD_URL}
+
+## Servicios Desplegados
+$(echo -e "${SERVICES_LIST}")
+
+## Imágenes Docker
+Todas las imágenes fueron desplegadas desde Docker Hub con el tag correspondiente al ambiente ${ENVIRONMENT}.
+
+## Últimos Cambios (Top 10 Commits)
+${GIT_LOG}
+
+## Infraestructura
+- **Namespace Kubernetes**: ${ENVIRONMENT}
+- **Orchestrator**: Kubernetes
+- **Container Registry**: Docker Hub
+- **CI/CD**: Jenkins
+
+## Estado del Deployment
+- Pre-cleanup ejecutado
+- Imágenes Docker verificadas
+- Manifiestos Kubernetes aplicados
+- Servicios y Pods verificados
+- Health checks completados
+
+## Validaciones
+- Build exitoso en Jenkins
+- Tests unitarios
+- Tests de integración
+- Deployment verificado
+
+## Notas Adicionales
+Este release fue generado automáticamente por el pipeline de Jenkins.
+
+### Enlaces Útiles
+- [Jenkins Build #${BUILD_NUMBER}](${BUILD_URL})
+- [GitHub Commit](https://github.com/JuanseDev2001/ecommerce-microservice-backend-app/commit/${GIT_HASH})
+
+---
+*Generado automáticamente el ${DATE} ${TIME}*
+EOF
+
+echo -e "${GREEN}Release Notes creadas exitosamente${NC}"
+echo -e "${BLUE}Archivo: ${RELEASE_FILE}${NC}"
+echo ""
+cat "${RELEASE_FILE}"
+
+exit 0
diff --git a/release-notes/version-manager.sh b/release-notes/version-manager.sh
new file mode 100755
index 000000000..2e23e04c2
--- /dev/null
+++ b/release-notes/version-manager.sh
@@ -0,0 +1,110 @@
+#!/bin/bash
+
+# Script para gestionar versiones automáticamente
+# Uso: ./version-manager.sh [major|minor|patch|auto]
+
+set -e
+
+# Colores
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+# Obtener la versión actual desde Git tags
+get_current_version() {
+ local latest_tag=$(git describe --tags --abbrev=0 2>/dev/null || echo "v-0.0.0")
+ # Remover 'v-' del inicio (mantener formato con guión)
+ echo "${latest_tag#v-}"
+}
+
+# Incrementar versión según tipo
+increment_version() {
+ local version=$1
+ local type=$2
+
+ IFS='.' read -r -a parts <<< "$version"
+ local major="${parts[0]:-0}"
+ local minor="${parts[1]:-0}"
+ local patch="${parts[2]:-0}"
+
+ case "$type" in
+ major)
+ major=$((major + 1))
+ minor=0
+ patch=0
+ ;;
+ minor)
+ minor=$((minor + 1))
+ patch=0
+ ;;
+ patch|auto)
+ patch=$((patch + 1))
+ ;;
+ *)
+ echo "Tipo inválido. Usa: major, minor, patch, o auto"
+ exit 1
+ ;;
+ esac
+
+ echo "${major}.${minor}.${patch}"
+}
+
+# Analizar commits para determinar tipo de versión (Conventional Commits)
+analyze_commits() {
+ local last_tag=$(git describe --tags --abbrev=0 2>/dev/null || git rev-list --max-parents=0 HEAD)
+ local commits=$(git log ${last_tag}..HEAD --pretty=format:"%s" 2>/dev/null || echo "")
+
+ # Buscar breaking changes (major)
+ if echo "$commits" | grep -qi "BREAKING CHANGE\|!:"; then
+ echo "major"
+ return
+ fi
+
+ # Buscar nuevas features (minor)
+ if echo "$commits" | grep -qi "^feat"; then
+ echo "minor"
+ return
+ fi
+
+ # Por defecto, patch
+ echo "patch"
+}
+
+# Main
+TYPE=${1:-auto}
+
+if [ "$TYPE" = "auto" ]; then
+ TYPE=$(analyze_commits)
+ echo -e "${YELLOW}Analizando commits... Tipo detectado: ${TYPE}${NC}"
+fi
+
+CURRENT_VERSION=$(get_current_version)
+NEW_VERSION=$(increment_version "$CURRENT_VERSION" "$TYPE")
+
+echo -e "${BLUE}Versión actual: ${CURRENT_VERSION}${NC}"
+echo -e "${GREEN}Nueva versión: ${NEW_VERSION}${NC}"
+echo ""
+echo -e "${YELLOW}¿Deseas crear el tag v${NEW_VERSION}? (y/n)${NC}"
+read -r response
+
+if [[ "$response" =~ ^[Yy]$ ]]; then
+ # Crear tag con formato v-X.Y.Z (con guión)
+ git tag -a "v-${NEW_VERSION}" -m "Release v-${NEW_VERSION}"
+ echo -e "${GREEN}Tag v-${NEW_VERSION} creado${NC}"
+ echo -e "${BLUE}Para pushear el tag: git push origin v-${NEW_VERSION}${NC}"
+ echo ""
+ echo -e "${YELLOW}¿Deseas generar las release notes ahora? (y/n)${NC}"
+ read -r gen_notes
+
+ if [[ "$gen_notes" =~ ^[Yy]$ ]]; then
+ # Corregir ruta cuando se ejecuta desde release-notes/
+ if [ -f "./generate-release-notes.sh" ]; then
+ ./generate-release-notes.sh "${NEW_VERSION}" "production"
+ else
+ ../release-notes/generate-release-notes.sh "${NEW_VERSION}" "production"
+ fi
+ fi
+else
+ echo -e "${YELLOW}Tag no creado${NC}"
+fi
diff --git a/scripts/README.md b/scripts/README.md
new file mode 100644
index 000000000..080bb2553
--- /dev/null
+++ b/scripts/README.md
@@ -0,0 +1,300 @@
+# Scripts de Utilidad para Azure VM
+
+Este directorio contiene scripts útiles para el despliegue y mantenimiento de la aplicación de microservicios en Azure VM.
+
+## 📋 Scripts Disponibles
+
+### 1. `azure-vm-setup.sh`
+**Propósito**: Configuración automática inicial de la VM de Azure.
+
+**Qué hace**:
+- Actualiza el sistema Ubuntu
+- Instala Docker y Docker Compose
+- Instala Java 11 y Maven
+- Configura límites del sistema para Elasticsearch
+- Crea swap de 8GB
+- Configura el firewall (UFW)
+- Crea directorios para datos persistentes
+
+**Uso**:
+```bash
+# En la VM de Azure (después de conectarte por SSH)
+wget https://raw.githubusercontent.com/TU_USUARIO/TU_REPO/main/scripts/azure-vm-setup.sh
+chmod +x azure-vm-setup.sh
+./azure-vm-setup.sh
+```
+
+**Nota**: Después de ejecutar este script, debes cerrar sesión y volver a conectarte para que los cambios de grupo de Docker tengan efecto.
+
+---
+
+### 2. `deploy-gradual.sh`
+**Propósito**: Despliegue gradual y ordenado de todos los servicios.
+
+**Qué hace**:
+- Inicia servicios en el orden correcto (infraestructura → gateway → microservicios → observabilidad)
+- Espera a que cada servicio esté listo antes de continuar
+- Verifica la salud de cada servicio
+- Muestra un resumen completo al final
+
+**Uso**:
+```bash
+cd ~/projects/ecommerce-microservice-backend-app
+chmod +x scripts/deploy-gradual.sh
+./scripts/deploy-gradual.sh
+```
+
+**Fases del despliegue**:
+1. **Infraestructura Base**: Zipkin, Eureka, Config Server
+2. **Gateway y Proxy**: API Gateway, Proxy Client
+3. **Microservicios**: User, Product, Order, Payment, Shipping, Favourite
+4. **Observabilidad**: Elasticsearch, Logstash, Kibana, Prometheus, Grafana, Jaeger
+
+---
+
+### 3. `check-services.sh`
+**Propósito**: Verificación del estado de todos los servicios.
+
+**Qué hace**:
+- Verifica que todos los contenedores Docker estén corriendo
+- Comprueba que todos los endpoints HTTP respondan
+- Lista servicios registrados en Eureka
+- Muestra uso de recursos (CPU, memoria, disco)
+- Genera un resumen del estado general
+
+**Uso**:
+```bash
+cd ~/projects/ecommerce-microservice-backend-app
+chmod +x scripts/check-services.sh
+./scripts/check-services.sh
+```
+
+**Código de salida**:
+- `0`: Todos los servicios funcionan correctamente
+- `1`: Algunos servicios tienen problemas
+
+---
+
+### 4. `backup.sh`
+**Propósito**: Backup de volúmenes Docker y configuraciones.
+
+**Qué hace**:
+- Respalda volúmenes de Docker (Jenkins, Grafana, Elasticsearch)
+- Respalda archivos de configuración (compose.yml, prometheus, elk, etc.)
+- Respalda scripts personalizados
+- Limpia backups antiguos (>7 días)
+- Genera reporte de backups creados
+
+**Uso**:
+```bash
+cd ~/projects/ecommerce-microservice-backend-app
+chmod +x scripts/backup.sh
+./scripts/backup.sh
+```
+
+**Configurar backup automático** (diario a las 2 AM):
+```bash
+(crontab -l 2>/dev/null; echo "0 2 * * * /home/azureuser/projects/ecommerce-microservice-backend-app/scripts/backup.sh") | crontab -
+```
+
+**Restaurar un backup**:
+```bash
+# Para volúmenes Docker
+docker run --rm \
+ -v :/data \
+ -v ~/backups:/backup \
+ ubuntu tar xzf /backup/.tar.gz -C /
+
+# Para configuraciones
+cd ~/projects/ecommerce-microservice-backend-app
+tar xzf ~/backups/config-.tar.gz
+```
+
+---
+
+## 🚀 Flujo de Trabajo Recomendado
+
+### Primera vez (VM nueva)
+
+```bash
+# 1. Configurar la VM
+./azure-vm-setup.sh
+
+# 2. Cerrar sesión y volver a conectar
+exit
+ssh -i ~/.ssh/vm-ecommerce-key.pem azureuser@
+
+# 3. Clonar el repositorio
+cd ~/projects
+git clone
+cd ecommerce-microservice-backend-app
+
+# 4. Dar permisos a los scripts
+chmod +x scripts/*.sh
+
+# 5. Desplegar servicios
+./scripts/deploy-gradual.sh
+
+# 6. Verificar estado
+./scripts/check-services.sh
+```
+
+### Mantenimiento regular
+
+```bash
+# Verificar estado de servicios
+./scripts/check-services.sh
+
+# Realizar backup manual
+./scripts/backup.sh
+
+# Reiniciar servicios si es necesario
+docker-compose -f compose.yml restart
+
+# Ver logs
+docker-compose -f compose.yml logs -f
+```
+
+### Actualización de servicios
+
+```bash
+# 1. Hacer backup
+./scripts/backup.sh
+
+# 2. Detener servicios
+docker-compose -f compose.yml down
+
+# 3. Actualizar código
+git pull
+
+# 4. Reconstruir imágenes (si es necesario)
+docker-compose -f compose.yml build
+
+# 5. Desplegar nuevamente
+./scripts/deploy-gradual.sh
+
+# 6. Verificar
+./scripts/check-services.sh
+```
+
+---
+
+## 🔧 Troubleshooting
+
+### Script falla con "Permission denied"
+```bash
+chmod +x scripts/.sh
+```
+
+### Servicios no inician correctamente
+```bash
+# Ver logs
+docker-compose -f compose.yml logs
+
+# Verificar recursos
+docker stats
+free -h
+df -h
+
+# Reiniciar servicio específico
+docker-compose -f compose.yml restart
+```
+
+### Elasticsearch no inicia
+```bash
+# Verificar límites de memoria virtual
+sysctl vm.max_map_count
+
+# Si es menor a 262144, ejecutar:
+sudo sysctl -w vm.max_map_count=262144
+```
+
+### Problemas de memoria
+```bash
+# Verificar swap
+free -h
+
+# Limpiar recursos de Docker
+docker system prune -a --volumes
+
+# Reiniciar servicios de observabilidad
+docker-compose -f compose.yml restart elasticsearch logstash kibana
+```
+
+---
+
+## 📊 Monitoreo
+
+### Ver uso de recursos en tiempo real
+```bash
+# CPU y memoria por contenedor
+docker stats
+
+# Uso general del sistema
+htop
+
+# Uso de disco
+df -h
+
+# Uso de red
+sudo iftop
+```
+
+### Acceder a servicios de monitoreo
+
+Desde tu navegador (reemplaza `` con la IP de tu VM):
+
+- **Prometheus**: `http://:9090`
+- **Grafana**: `http://:3000` (admin/admin)
+- **Kibana**: `http://:5601`
+- **Jaeger**: `http://:16686`
+- **Eureka**: `http://:8761`
+
+---
+
+## 🔒 Seguridad
+
+### Recomendaciones
+
+1. **Cambiar contraseñas por defecto**:
+ - Grafana: admin/admin → cambiar en primer login
+ - Elasticsearch: configurar autenticación si se expone públicamente
+
+2. **Restringir acceso por IP** (en Azure NSG):
+ - Permitir solo IPs conocidas para servicios de administración
+ - Exponer solo API Gateway públicamente
+
+3. **Usar HTTPS**:
+ - Configurar certificados SSL/TLS
+ - Usar Let's Encrypt para certificados gratuitos
+
+4. **Actualizar regularmente**:
+ ```bash
+ sudo apt update && sudo apt upgrade -y
+ docker-compose pull
+ ```
+
+---
+
+## 📝 Notas Adicionales
+
+- Todos los scripts están diseñados para Ubuntu 22.04 LTS
+- Los backups se almacenan en `~/backups`
+- Los logs de Docker se rotan automáticamente (max 10MB, 3 archivos)
+- El swap configurado es de 8GB
+- Los volúmenes persistentes se crean automáticamente
+
+---
+
+## 🆘 Soporte
+
+Si encuentras problemas:
+
+1. Revisa los logs: `docker-compose logs `
+2. Ejecuta el script de verificación: `./scripts/check-services.sh`
+3. Consulta la guía completa: `docs/azure-vm-deployment-guide.md`
+4. Abre un issue en el repositorio
+
+---
+
+**Última actualización**: 2025-11-30
diff --git a/scripts/azure-vm-setup.sh b/scripts/azure-vm-setup.sh
new file mode 100755
index 000000000..bd0501129
--- /dev/null
+++ b/scripts/azure-vm-setup.sh
@@ -0,0 +1,206 @@
+#!/bin/bash
+
+###############################################################################
+# Script de Configuración Automática para Azure VM
+# Este script instala y configura todo lo necesario para correr el proyecto
+###############################################################################
+
+set -e # Salir si hay algún error
+
+# Colores para output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Función para imprimir mensajes
+print_message() {
+ echo -e "${GREEN}[INFO]${NC} $1"
+}
+
+print_error() {
+ echo -e "${RED}[ERROR]${NC} $1"
+}
+
+print_warning() {
+ echo -e "${YELLOW}[WARNING]${NC} $1"
+}
+
+# Verificar que se ejecuta en Ubuntu
+if [ ! -f /etc/lsb-release ]; then
+ print_error "Este script está diseñado para Ubuntu"
+ exit 1
+fi
+
+print_message "=== Iniciando configuración de Azure VM para E-Commerce Microservices ==="
+
+# 1. Actualizar el sistema
+print_message "Actualizando el sistema..."
+sudo apt update
+sudo apt upgrade -y
+
+# 2. Instalar utilidades básicas
+print_message "Instalando utilidades básicas..."
+sudo apt install -y \
+ curl \
+ wget \
+ git \
+ vim \
+ nano \
+ net-tools \
+ htop \
+ iotop \
+ jq \
+ unzip \
+ apt-transport-https \
+ ca-certificates \
+ software-properties-common
+
+# 3. Instalar Docker
+print_message "Instalando Docker..."
+if ! command -v docker &> /dev/null; then
+ # Agregar clave GPG de Docker
+ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
+
+ # Agregar repositorio
+ echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
+
+ # Instalar Docker
+ sudo apt update
+ sudo apt install -y docker-ce docker-ce-cli containerd.io
+
+ # Agregar usuario al grupo docker
+ sudo usermod -aG docker $USER
+
+ print_message "Docker instalado correctamente"
+else
+ print_warning "Docker ya está instalado"
+fi
+
+# 4. Instalar Docker Compose
+print_message "Instalando Docker Compose..."
+if ! command -v docker-compose &> /dev/null; then
+ sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
+ sudo chmod +x /usr/local/bin/docker-compose
+ print_message "Docker Compose instalado correctamente"
+else
+ print_warning "Docker Compose ya está instalado"
+fi
+
+# 5. Instalar Java 11
+print_message "Instalando Java 11..."
+if ! command -v java &> /dev/null; then
+ sudo apt install -y openjdk-11-jdk
+
+ # Configurar JAVA_HOME
+ echo 'export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64' >> ~/.bashrc
+ echo 'export PATH=$PATH:$JAVA_HOME/bin' >> ~/.bashrc
+
+ print_message "Java 11 instalado correctamente"
+else
+ print_warning "Java ya está instalado"
+fi
+
+# 6. Instalar Maven
+print_message "Instalando Maven..."
+if ! command -v mvn &> /dev/null; then
+ sudo apt install -y maven
+ print_message "Maven instalado correctamente"
+else
+ print_warning "Maven ya está instalado"
+fi
+
+# 7. Configurar límites del sistema para Elasticsearch
+print_message "Configurando límites del sistema..."
+sudo sysctl -w vm.max_map_count=262144
+echo 'vm.max_map_count=262144' | sudo tee -a /etc/sysctl.conf
+
+# 8. Configurar Swap (8GB)
+print_message "Configurando Swap..."
+if [ ! -f /swapfile ]; then
+ sudo fallocate -l 8G /swapfile
+ sudo chmod 600 /swapfile
+ sudo mkswap /swapfile
+ sudo swapon /swapfile
+ echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab
+ print_message "Swap configurado correctamente"
+else
+ print_warning "Swap ya está configurado"
+fi
+
+# 9. Configurar Docker daemon
+print_message "Configurando Docker daemon..."
+sudo mkdir -p /etc/docker
+cat << EOF | sudo tee /etc/docker/daemon.json
+{
+ "log-driver": "json-file",
+ "log-opts": {
+ "max-size": "10m",
+ "max-file": "3"
+ },
+ "default-ulimits": {
+ "nofile": {
+ "Name": "nofile",
+ "Hard": 64000,
+ "Soft": 64000
+ }
+ }
+}
+EOF
+
+sudo systemctl restart docker
+
+# 10. Configurar firewall (UFW)
+print_message "Configurando firewall..."
+sudo ufw --force enable
+sudo ufw allow 22/tcp # SSH
+sudo ufw allow 80/tcp # HTTP
+sudo ufw allow 443/tcp # HTTPS
+sudo ufw allow 3000/tcp # Grafana
+sudo ufw allow 5000/tcp # Logstash
+sudo ufw allow 5601/tcp # Kibana
+sudo ufw allow 8080/tcp # API Gateway
+sudo ufw allow 8300/tcp # Order Service
+sudo ufw allow 8400/tcp # Payment Service
+sudo ufw allow 8500/tcp # Product Service
+sudo ufw allow 8600/tcp # Shipping Service
+sudo ufw allow 8700/tcp # User Service
+sudo ufw allow 8800/tcp # Favourite Service
+sudo ufw allow 8900/tcp # Proxy Client
+sudo ufw allow 9090/tcp # Prometheus
+sudo ufw allow 9093/tcp # Alertmanager
+sudo ufw allow 9200/tcp # Elasticsearch
+sudo ufw allow 9296/tcp # Config Server
+sudo ufw allow 9411/tcp # Zipkin
+sudo ufw allow 8761/tcp # Eureka
+sudo ufw allow 16686/tcp # Jaeger UI
+sudo ufw reload
+
+# 11. Crear directorios para datos persistentes
+print_message "Creando directorios para datos persistentes..."
+sudo mkdir -p /data/{grafana,prometheus,elasticsearch,jenkins}
+sudo chown -R 472:472 /data/grafana
+sudo chown -R 65534:65534 /data/prometheus
+sudo chown -R 1000:1000 /data/elasticsearch
+sudo chown -R 1000:1000 /data/jenkins
+
+# 12. Crear directorio de proyectos
+print_message "Creando directorio de proyectos..."
+mkdir -p ~/projects
+mkdir -p ~/backups
+
+print_message "=== Configuración completada ==="
+print_message ""
+print_message "Versiones instaladas:"
+echo " - Docker: $(docker --version)"
+echo " - Docker Compose: $(docker-compose --version)"
+echo " - Java: $(java -version 2>&1 | head -n 1)"
+echo " - Maven: $(mvn -version | head -n 1)"
+print_message ""
+print_warning "IMPORTANTE: Cierra la sesión SSH y vuelve a conectarte para que los cambios de grupo de Docker tengan efecto"
+print_message ""
+print_message "Próximos pasos:"
+print_message " 1. Cerrar sesión: exit"
+print_message " 2. Volver a conectar por SSH"
+print_message " 3. Clonar el repositorio: cd ~/projects && git clone "
+print_message " 4. Ejecutar: cd ecommerce-microservice-backend-app && docker-compose -f compose.yml up -d"
diff --git a/scripts/backup.sh b/scripts/backup.sh
new file mode 100755
index 000000000..ecd7f1e4a
--- /dev/null
+++ b/scripts/backup.sh
@@ -0,0 +1,111 @@
+#!/bin/bash
+
+###############################################################################
+# Script de Backup para E-Commerce Microservices
+# Realiza backup de volúmenes Docker y configuraciones
+###############################################################################
+
+# Configuración
+BACKUP_DIR="${HOME}/backups"
+DATE=$(date +%Y%m%d_%H%M%S)
+PROJECT_DIR="${HOME}/projects/ecommerce-microservice-backend-app"
+
+# Colores
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+NC='\033[0m'
+
+# Crear directorio de backups
+mkdir -p "$BACKUP_DIR"
+
+echo -e "${GREEN}=== Iniciando Backup ===${NC}"
+echo "Fecha: $(date)"
+echo "Directorio de backup: $BACKUP_DIR"
+echo ""
+
+# 1. Backup de volúmenes de Docker
+echo -e "${YELLOW}Realizando backup de volúmenes Docker...${NC}"
+
+volumes=("jenkins_home" "grafana-storage" "elasticsearch-data")
+
+for volume in "${volumes[@]}"; do
+ if docker volume inspect "$volume" > /dev/null 2>&1; then
+ echo " • Backup de $volume..."
+ docker run --rm \
+ -v "${volume}:/data" \
+ -v "${BACKUP_DIR}:/backup" \
+ ubuntu tar czf "/backup/${volume}-${DATE}.tar.gz" /data
+
+ if [ $? -eq 0 ]; then
+ echo -e " ${GREEN}✓ Completado${NC}"
+ else
+ echo -e " ${RED}✗ Error${NC}"
+ fi
+ else
+ echo " • Volumen $volume no existe, saltando..."
+ fi
+done
+
+# 2. Backup de configuraciones
+echo -e "\n${YELLOW}Realizando backup de configuraciones...${NC}"
+
+if [ -d "$PROJECT_DIR" ]; then
+ cd "$PROJECT_DIR" || exit
+
+ tar czf "${BACKUP_DIR}/config-${DATE}.tar.gz" \
+ compose.yml \
+ docker-compose.observability.yml \
+ prometheus/ \
+ elk/ \
+ .env 2>/dev/null
+
+ if [ $? -eq 0 ]; then
+ echo -e " ${GREEN}✓ Configuraciones respaldadas${NC}"
+ else
+ echo -e " ${RED}✗ Error al respaldar configuraciones${NC}"
+ fi
+else
+ echo -e " ${RED}✗ Directorio del proyecto no encontrado${NC}"
+fi
+
+# 3. Backup de scripts personalizados
+echo -e "\n${YELLOW}Realizando backup de scripts...${NC}"
+
+if [ -d "${PROJECT_DIR}/scripts" ]; then
+ tar czf "${BACKUP_DIR}/scripts-${DATE}.tar.gz" -C "$PROJECT_DIR" scripts/
+ echo -e " ${GREEN}✓ Scripts respaldados${NC}"
+fi
+
+# 4. Listar backups
+echo -e "\n${YELLOW}Backups creados:${NC}"
+ls -lh "$BACKUP_DIR" | grep "$DATE"
+
+# 5. Calcular tamaño total
+total_size=$(du -sh "$BACKUP_DIR" | cut -f1)
+echo -e "\nTamaño total de backups: ${GREEN}$total_size${NC}"
+
+# 6. Limpiar backups antiguos (mantener últimos 7 días)
+echo -e "\n${YELLOW}Limpiando backups antiguos (>7 días)...${NC}"
+old_backups=$(find "$BACKUP_DIR" -name "*.tar.gz" -mtime +7)
+
+if [ -n "$old_backups" ]; then
+ echo "$old_backups" | while read file; do
+ echo " • Eliminando: $(basename "$file")"
+ rm -f "$file"
+ done
+ echo -e "${GREEN}✓ Backups antiguos eliminados${NC}"
+else
+ echo " No hay backups antiguos para eliminar"
+fi
+
+# 7. Resumen
+echo -e "\n${GREEN}=== Backup Completado ===${NC}"
+echo "Archivos de backup:"
+ls -1 "$BACKUP_DIR" | grep "$DATE" | while read file; do
+ size=$(du -h "${BACKUP_DIR}/${file}" | cut -f1)
+ echo " • $file ($size)"
+done
+
+echo -e "\n${YELLOW}Para restaurar un backup:${NC}"
+echo " docker run --rm -v :/data -v ${BACKUP_DIR}:/backup ubuntu tar xzf /backup/.tar.gz -C /"
diff --git a/scripts/check-services.sh b/scripts/check-services.sh
new file mode 100755
index 000000000..e158c8b88
--- /dev/null
+++ b/scripts/check-services.sh
@@ -0,0 +1,173 @@
+#!/bin/bash
+
+###############################################################################
+# Script de Verificación de Servicios
+# Verifica que todos los microservicios estén corriendo correctamente
+###############################################################################
+
+# Colores
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+# Función para verificar un servicio HTTP
+check_http_service() {
+ local name=$1
+ local url=$2
+ local max_attempts=${3:-30}
+ local attempt=1
+
+ echo -n "Verificando $name... "
+
+ while [ $attempt -le $max_attempts ]; do
+ if curl -s -f "$url" > /dev/null 2>&1; then
+ echo -e "${GREEN}✓ OK${NC}"
+ return 0
+ fi
+ sleep 2
+ attempt=$((attempt + 1))
+ done
+
+ echo -e "${RED}✗ TIMEOUT${NC}"
+ return 1
+}
+
+# Función para verificar un contenedor Docker
+check_container() {
+ local container_name=$1
+
+ if docker ps --format '{{.Names}}' | grep -q "^${container_name}$"; then
+ local status=$(docker inspect --format='{{.State.Status}}' "$container_name")
+ if [ "$status" = "running" ]; then
+ echo -e "${GREEN}✓${NC} $container_name: running"
+ return 0
+ else
+ echo -e "${RED}✗${NC} $container_name: $status"
+ return 1
+ fi
+ else
+ echo -e "${RED}✗${NC} $container_name: not found"
+ return 1
+ fi
+}
+
+# Banner
+echo -e "${BLUE}"
+echo "╔═══════════════════════════════════════════════════════════╗"
+echo "║ E-Commerce Microservices - Verificación de Servicios ║"
+echo "╚═══════════════════════════════════════════════════════════╝"
+echo -e "${NC}"
+
+# 1. Verificar contenedores Docker
+echo -e "\n${YELLOW}=== Verificando Contenedores Docker ===${NC}\n"
+
+containers=(
+ "zipkin"
+ "service-discovery-container"
+ "cloud-config-container"
+ "api-gateway-container"
+ "proxy-client-container"
+ "order-service-container"
+ "payment-service-container"
+ "product-service-container"
+ "shipping-service-container"
+ "user-service-container"
+ "favourite-service-container"
+ "prometheus"
+ "alertmanager"
+ "grafana"
+ "jaeger"
+ "elasticsearch"
+ "logstash"
+ "kibana"
+)
+
+container_failures=0
+for container in "${containers[@]}"; do
+ if ! check_container "$container"; then
+ ((container_failures++))
+ fi
+done
+
+# 2. Verificar servicios HTTP
+echo -e "\n${YELLOW}=== Verificando Servicios HTTP ===${NC}\n"
+
+service_failures=0
+
+# Infraestructura
+echo -e "${BLUE}Infraestructura:${NC}"
+check_http_service "Eureka" "http://localhost:8761" || ((service_failures++))
+check_http_service "Config Server" "http://localhost:9296/actuator/health" || ((service_failures++))
+check_http_service "API Gateway" "http://localhost:8080/actuator/health" || ((service_failures++))
+check_http_service "Zipkin" "http://localhost:9411" || ((service_failures++))
+
+# Microservicios
+echo -e "\n${BLUE}Microservicios:${NC}"
+check_http_service "Proxy Client" "http://localhost:8900/actuator/health" || ((service_failures++))
+check_http_service "Order Service" "http://localhost:8300/actuator/health" || ((service_failures++))
+check_http_service "Payment Service" "http://localhost:8400/actuator/health" || ((service_failures++))
+check_http_service "Product Service" "http://localhost:8500/actuator/health" || ((service_failures++))
+check_http_service "Shipping Service" "http://localhost:8600/actuator/health" || ((service_failures++))
+check_http_service "User Service" "http://localhost:8700/actuator/health" || ((service_failures++))
+check_http_service "Favourite Service" "http://localhost:8800/actuator/health" || ((service_failures++))
+
+# Observabilidad
+echo -e "\n${BLUE}Observabilidad:${NC}"
+check_http_service "Prometheus" "http://localhost:9090/-/healthy" || ((service_failures++))
+check_http_service "Alertmanager" "http://localhost:9093/-/healthy" || ((service_failures++))
+check_http_service "Grafana" "http://localhost:3000/api/health" || ((service_failures++))
+check_http_service "Jaeger" "http://localhost:16686" || ((service_failures++))
+check_http_service "Elasticsearch" "http://localhost:9200/_cluster/health" || ((service_failures++))
+check_http_service "Kibana" "http://localhost:5601/api/status" || ((service_failures++))
+
+# 3. Verificar servicios registrados en Eureka
+echo -e "\n${YELLOW}=== Servicios Registrados en Eureka ===${NC}\n"
+
+if curl -s http://localhost:8761/eureka/apps > /dev/null 2>&1; then
+ registered_services=$(curl -s http://localhost:8761/eureka/apps | grep -o '[^<]*' | sed 's///g' | sed 's/<\/name>//g' | sort -u)
+
+ if [ -n "$registered_services" ]; then
+ echo "$registered_services" | while read service; do
+ echo -e "${GREEN}✓${NC} $service"
+ done
+ else
+ echo -e "${RED}No se encontraron servicios registrados${NC}"
+ fi
+else
+ echo -e "${RED}No se pudo conectar a Eureka${NC}"
+fi
+
+# 4. Verificar uso de recursos
+echo -e "\n${YELLOW}=== Uso de Recursos ===${NC}\n"
+
+echo -e "${BLUE}Memoria:${NC}"
+free -h | grep -E "Mem:|Swap:"
+
+echo -e "\n${BLUE}Disco:${NC}"
+df -h | grep -E "Filesystem|/dev/sda1"
+
+echo -e "\n${BLUE}Top 5 Contenedores por Uso de CPU:${NC}"
+docker stats --no-stream --format "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}" | head -n 6
+
+# 5. Resumen
+echo -e "\n${YELLOW}=== Resumen ===${NC}\n"
+
+total_containers=${#containers[@]}
+total_services=17 # Número total de servicios HTTP verificados
+
+echo "Contenedores: $((total_containers - container_failures))/$total_containers corriendo"
+echo "Servicios HTTP: $((total_services - service_failures))/$total_services respondiendo"
+
+if [ $container_failures -eq 0 ] && [ $service_failures -eq 0 ]; then
+ echo -e "\n${GREEN}✓ Todos los servicios están funcionando correctamente${NC}"
+ exit 0
+else
+ echo -e "\n${RED}✗ Algunos servicios tienen problemas${NC}"
+ echo -e "\nPara ver logs de un servicio específico:"
+ echo " docker-compose -f compose.yml logs "
+ echo -e "\nPara reiniciar un servicio:"
+ echo " docker-compose -f compose.yml restart "
+ exit 1
+fi
diff --git a/scripts/deploy-gradual.sh b/scripts/deploy-gradual.sh
new file mode 100755
index 000000000..d46dec1b2
--- /dev/null
+++ b/scripts/deploy-gradual.sh
@@ -0,0 +1,203 @@
+#!/bin/bash
+
+###############################################################################
+# Script de Despliegue Gradual
+# Inicia los servicios en el orden correcto con verificaciones
+###############################################################################
+
+# Colores
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+# Función para esperar que un servicio esté listo
+wait_for_service() {
+ local name=$1
+ local url=$2
+ local max_wait=${3:-300} # 5 minutos por defecto
+ local elapsed=0
+
+ echo -n "Esperando a que $name esté listo..."
+
+ while [ $elapsed -lt $max_wait ]; do
+ if curl -s -f "$url" > /dev/null 2>&1; then
+ echo -e " ${GREEN}✓ Listo${NC} (${elapsed}s)"
+ return 0
+ fi
+ echo -n "."
+ sleep 5
+ elapsed=$((elapsed + 5))
+ done
+
+ echo -e " ${RED}✗ Timeout${NC}"
+ return 1
+}
+
+# Banner
+echo -e "${BLUE}"
+echo "╔═══════════════════════════════════════════════════════════╗"
+echo "║ E-Commerce Microservices - Despliegue Gradual ║"
+echo "╚═══════════════════════════════════════════════════════════╝"
+echo -e "${NC}"
+
+# Verificar que estamos en el directorio correcto
+if [ ! -f "compose.yml" ]; then
+ echo -e "${RED}Error: No se encontró compose.yml${NC}"
+ echo "Por favor, ejecuta este script desde el directorio del proyecto"
+ exit 1
+fi
+
+# Preguntar si detener servicios existentes
+echo -e "${YELLOW}¿Deseas detener los servicios existentes primero? (s/n)${NC}"
+read -r response
+if [[ "$response" =~ ^[Ss]$ ]]; then
+ echo -e "\n${BLUE}Deteniendo servicios existentes...${NC}"
+ docker-compose -f compose.yml down
+ echo -e "${GREEN}Servicios detenidos${NC}"
+ sleep 5
+fi
+
+# Fase 1: Infraestructura Base
+echo -e "\n${YELLOW}=== Fase 1: Infraestructura Base ===${NC}\n"
+
+echo "Iniciando Zipkin..."
+docker-compose -f compose.yml up -d zipkin
+wait_for_service "Zipkin" "http://localhost:9411" 60
+
+echo -e "\nIniciando Service Discovery (Eureka)..."
+docker-compose -f compose.yml up -d service-discovery-container
+wait_for_service "Eureka" "http://localhost:8761" 120
+
+echo -e "\nIniciando Cloud Config Server..."
+docker-compose -f compose.yml up -d cloud-config-container
+wait_for_service "Config Server" "http://localhost:9296/actuator/health" 120
+
+echo -e "${GREEN}✓ Infraestructura base lista${NC}"
+sleep 10
+
+# Fase 2: API Gateway y Proxy
+echo -e "\n${YELLOW}=== Fase 2: API Gateway y Proxy ===${NC}\n"
+
+echo "Iniciando API Gateway..."
+docker-compose -f compose.yml up -d api-gateway-container
+wait_for_service "API Gateway" "http://localhost:8080/actuator/health" 120
+
+echo -e "\nIniciando Proxy Client..."
+docker-compose -f compose.yml up -d proxy-client-container
+wait_for_service "Proxy Client" "http://localhost:8900/actuator/health" 120
+
+echo -e "${GREEN}✓ Gateway y Proxy listos${NC}"
+sleep 10
+
+# Fase 3: Microservicios de Negocio
+echo -e "\n${YELLOW}=== Fase 3: Microservicios de Negocio ===${NC}\n"
+
+services=(
+ "user-service-container:8700"
+ "product-service-container:8500"
+ "order-service-container:8300"
+ "payment-service-container:8400"
+ "shipping-service-container:8600"
+ "favourite-service-container:8800"
+)
+
+for service_info in "${services[@]}"; do
+ IFS=':' read -r service port <<< "$service_info"
+ service_name=$(echo "$service" | sed 's/-container//' | sed 's/-/ /g' | awk '{for(i=1;i<=NF;i++)sub(/./,toupper(substr($i,1,1)),$i)}1')
+
+ echo -e "\nIniciando $service_name..."
+ docker-compose -f compose.yml up -d "$service"
+ wait_for_service "$service_name" "http://localhost:$port/actuator/health" 120
+done
+
+echo -e "${GREEN}✓ Microservicios de negocio listos${NC}"
+sleep 10
+
+# Fase 4: Stack de Observabilidad
+echo -e "\n${YELLOW}=== Fase 4: Stack de Observabilidad ===${NC}\n"
+
+echo "Iniciando Elasticsearch..."
+docker-compose -f compose.yml up -d elasticsearch
+wait_for_service "Elasticsearch" "http://localhost:9200/_cluster/health" 180
+
+echo -e "\nIniciando Logstash..."
+docker-compose -f compose.yml up -d logstash
+sleep 30 # Logstash tarda en iniciar
+
+echo -e "\nIniciando Kibana..."
+docker-compose -f compose.yml up -d kibana
+wait_for_service "Kibana" "http://localhost:5601/api/status" 180
+
+echo -e "\nIniciando Prometheus..."
+docker-compose -f compose.yml up -d prometheus
+wait_for_service "Prometheus" "http://localhost:9090/-/healthy" 60
+
+echo -e "\nIniciando Alertmanager..."
+docker-compose -f compose.yml up -d alertmanager
+wait_for_service "Alertmanager" "http://localhost:9093/-/healthy" 60
+
+echo -e "\nIniciando Grafana..."
+docker-compose -f compose.yml up -d grafana
+wait_for_service "Grafana" "http://localhost:3000/api/health" 120
+
+echo -e "\nIniciando Jaeger..."
+docker-compose -f compose.yml up -d jaeger
+wait_for_service "Jaeger" "http://localhost:16686" 60
+
+echo -e "${GREEN}✓ Stack de observabilidad listo${NC}"
+
+# Resumen final
+echo -e "\n${YELLOW}=== Resumen del Despliegue ===${NC}\n"
+
+echo "Estado de los contenedores:"
+docker-compose -f compose.yml ps
+
+echo -e "\n${BLUE}Servicios disponibles:${NC}"
+echo ""
+echo "Infraestructura:"
+echo " • Eureka: http://localhost:8761"
+echo " • Config Server: http://localhost:9296"
+echo " • API Gateway: http://localhost:8080"
+echo " • Zipkin: http://localhost:9411"
+echo ""
+echo "Microservicios:"
+echo " • User Service: http://localhost:8700/swagger-ui.html"
+echo " • Product Service: http://localhost:8500/swagger-ui.html"
+echo " • Order Service: http://localhost:8300/swagger-ui.html"
+echo " • Payment Service: http://localhost:8400/swagger-ui.html"
+echo " • Shipping Service: http://localhost:8600/swagger-ui.html"
+echo " • Favourite Service: http://localhost:8800/swagger-ui.html"
+echo " • Proxy Client: http://localhost:8900/swagger-ui.html"
+echo ""
+echo "Observabilidad:"
+echo " • Prometheus: http://localhost:9090"
+echo " • Grafana: http://localhost:3000 (admin/admin)"
+echo " • Kibana: http://localhost:5601"
+echo " • Jaeger: http://localhost:16686"
+echo ""
+
+# Verificar servicios registrados en Eureka
+echo -e "${BLUE}Servicios registrados en Eureka:${NC}"
+sleep 5 # Dar tiempo para que se registren
+if curl -s http://localhost:8761/eureka/apps > /dev/null 2>&1; then
+ registered=$(curl -s http://localhost:8761/eureka/apps | grep -o '[^<]*' | sed 's///g' | sed 's/<\/name>//g' | sort -u | wc -l)
+ echo " Total: $registered servicios"
+ curl -s http://localhost:8761/eureka/apps | grep -o '[^<]*' | sed 's///g' | sed 's/<\/name>//g' | sort -u | while read service; do
+ echo " • $service"
+ done
+else
+ echo -e " ${RED}No se pudo conectar a Eureka${NC}"
+fi
+
+echo -e "\n${GREEN}╔═══════════════════════════════════════════════════════════╗${NC}"
+echo -e "${GREEN}║ ✓ Despliegue completado exitosamente ║${NC}"
+echo -e "${GREEN}╚═══════════════════════════════════════════════════════════╝${NC}"
+
+echo -e "\n${YELLOW}Próximos pasos:${NC}"
+echo " 1. Verifica el estado: ./scripts/check-services.sh"
+echo " 2. Ejecuta los tests: ./test-em-all.sh"
+echo " 3. Accede a Grafana y configura los dashboards"
+echo " 4. Revisa los logs: docker-compose -f compose.yml logs -f"
+echo ""
diff --git a/service-discovery/Dockerfile b/service-discovery/Dockerfile
index 7562e96fa..b59a4f9f5 100644
--- a/service-discovery/Dockerfile
+++ b/service-discovery/Dockerfile
@@ -3,10 +3,8 @@ FROM openjdk:11
ARG PROJECT_VERSION=0.1.0
RUN mkdir -p /home/app
WORKDIR /home/app
-ENV SPRING_PROFILES_ACTIVE dev
+ENV SPRING_PROFILES_ACTIVE=dev
COPY service-discovery/ .
ADD service-discovery/target/service-discovery-v${PROJECT_VERSION}.jar service-discovery.jar
EXPOSE 8761
-ENTRYPOINT ["java", "-Dspring.profiles.active=${SPRING_PROFILES_ACTIVE}", "-jar", "service-discovery.jar"]
-
-
+ENTRYPOINT ["java", "-Dspring.profiles.active=${SPRING_PROFILES_ACTIVE}", "-jar", "service-discovery.jar"]
\ No newline at end of file
diff --git a/service-discovery/compose.yml b/service-discovery/compose.yml
index 21226ed39..a08bb45f4 100644
--- a/service-discovery/compose.yml
+++ b/service-discovery/compose.yml
@@ -1,8 +1,7 @@
-
version: '3'
services:
service-discovery-container:
- image: selimhorri/service-discovery-ecommerce-boot:0.1.0
+ image: juanse201/service-discovery-ecommerce-boot:0.1.0
ports:
- 8761:8761
environment:
diff --git a/service-discovery/src/main/resources/application.yml b/service-discovery/src/main/resources/application.yml
index 8af09cce0..ac839eeaf 100644
--- a/service-discovery/src/main/resources/application.yml
+++ b/service-discovery/src/main/resources/application.yml
@@ -1,7 +1,7 @@
spring:
zipkin:
- base-url: ${SPRING_ZIPKIN_BASE_URL:http://localhost:9411/}
+ base-url: ${SPRING_ZIPKIN_BASE_URL:http://zipkin:9411/}
application:
name: SERVICE-DISCOVERY
profiles:
diff --git a/service-discovery/src/test/java/com/selimhorri/app/integration/ServiceDiscoveryApplicationIntegrationTest.java b/service-discovery/src/test/java/com/selimhorri/app/integration/ServiceDiscoveryApplicationIntegrationTest.java
new file mode 100644
index 000000000..9875323aa
--- /dev/null
+++ b/service-discovery/src/test/java/com/selimhorri/app/integration/ServiceDiscoveryApplicationIntegrationTest.java
@@ -0,0 +1,29 @@
+package com.selimhorri.app.integration;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
+import static org.junit.jupiter.api.Assertions.*;
+
+@SpringBootTest
+public class ServiceDiscoveryApplicationIntegrationTest {
+
+ @Test
+ void contextLoads() {
+ // Spring context should load without exceptions
+ }
+
+ @Test
+ void testApplicationClassIsNotNull() {
+ assertNotNull(com.selimhorri.app.ServiceDiscoveryApplication.class);
+ }
+
+ @Test
+ void testSpringBootApplicationAnnotationPresent() {
+ assertTrue(com.selimhorri.app.ServiceDiscoveryApplication.class.isAnnotationPresent(org.springframework.boot.autoconfigure.SpringBootApplication.class));
+ }
+
+ @Test
+ void testEnableEurekaServerAnnotationPresent() {
+ assertTrue(com.selimhorri.app.ServiceDiscoveryApplication.class.isAnnotationPresent(org.springframework.cloud.netflix.eureka.server.EnableEurekaServer.class));
+ }
+}
diff --git a/service-discovery/src/test/java/com/selimhorri/app/unit/ServiceDiscoveryApplicationUnitTest.java b/service-discovery/src/test/java/com/selimhorri/app/unit/ServiceDiscoveryApplicationUnitTest.java
new file mode 100644
index 000000000..d8e4bafd5
--- /dev/null
+++ b/service-discovery/src/test/java/com/selimhorri/app/unit/ServiceDiscoveryApplicationUnitTest.java
@@ -0,0 +1,41 @@
+package com.selimhorri.app.unit;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class ServiceDiscoveryApplicationUnitTest {
+
+ @Test
+ void testMainMethodExists() {
+ // Just check that the main method exists and is public static
+ try {
+ java.lang.reflect.Method main = com.selimhorri.app.ServiceDiscoveryApplication.class.getMethod("main", String[].class);
+ int modifiers = main.getModifiers();
+ assertTrue(java.lang.reflect.Modifier.isPublic(modifiers));
+ assertTrue(java.lang.reflect.Modifier.isStatic(modifiers));
+ } catch (NoSuchMethodException e) {
+ fail("main method not found");
+ }
+ }
+
+ @Test
+ void testMainWithNullArgsThrows() {
+ // Should throw IllegalArgumentException if null is passed
+ assertThrows(IllegalArgumentException.class, () -> com.selimhorri.app.ServiceDiscoveryApplication.main(null));
+ }
+
+ @Test
+ void testClassHasSpringBootApplicationAnnotation() {
+ assertTrue(com.selimhorri.app.ServiceDiscoveryApplication.class.isAnnotationPresent(org.springframework.boot.autoconfigure.SpringBootApplication.class));
+ }
+
+ @Test
+ void testClassHasEnableEurekaServerAnnotation() {
+ assertTrue(com.selimhorri.app.ServiceDiscoveryApplication.class.isAnnotationPresent(org.springframework.cloud.netflix.eureka.server.EnableEurekaServer.class));
+ }
+
+ @Test
+ void testClassName() {
+ assertEquals("ServiceDiscoveryApplication", com.selimhorri.app.ServiceDiscoveryApplication.class.getSimpleName());
+ }
+}
diff --git a/shipping-service/Dockerfile b/shipping-service/Dockerfile
index c678aef31..48844f563 100644
--- a/shipping-service/Dockerfile
+++ b/shipping-service/Dockerfile
@@ -3,10 +3,8 @@ FROM openjdk:11
ARG PROJECT_VERSION=0.1.0
RUN mkdir -p /home/app
WORKDIR /home/app
-ENV SPRING_PROFILES_ACTIVE dev
+ENV SPRING_PROFILES_ACTIVE=dev
COPY shipping-service/ .
ADD shipping-service/target/shipping-service-v${PROJECT_VERSION}.jar shipping-service.jar
EXPOSE 8600
-ENTRYPOINT ["java", "-Dspring.profiles.active=${SPRING_PROFILES_ACTIVE}", "-jar", "shipping-service.jar"]
-
-
+ENTRYPOINT ["java", "-Dspring.profiles.active=${SPRING_PROFILES_ACTIVE}", "-jar", "shipping-service.jar"]
\ No newline at end of file
diff --git a/shipping-service/compose.yml b/shipping-service/compose.yml
index 81878a33a..7bc9d4572 100644
--- a/shipping-service/compose.yml
+++ b/shipping-service/compose.yml
@@ -1,12 +1,23 @@
-
version: '3'
services:
shipping-service-container:
- image: selimhorri/shipping-service-ecommerce-boot:0.1.0
+ image: juanse201/shipping-service-ecommerce-boot:0.1.0
ports:
- 8600:8600
environment:
- SPRING_PROFILES_ACTIVE=dev
+ - SPRING_ZIPKIN_BASE_URL=http://zipkin:9411
+ - SPRING_CONFIG_IMPORT=optional:configserver:http://cloud-config-container:9296/
+ - EUREKA_CLIENT_REGION=default
+ - EUREKA_CLIENT_AVAILABILITY_ZONES_DEFAULT=myzone
+ - EUREKA_CLIENT_SERVICEURL_MYZONE=http://service-discovery-container:8761/eureka
+ - EUREKA_CLIENT_SERVICEURL_DEFAULTZONE=http://service-discovery-container:8761/eureka/
+ networks:
+ - microservices_network
+networks:
+ microservices_network:
+ external: true
+ name: microservices_network
diff --git a/shipping-service/pom.xml b/shipping-service/pom.xml
index 9e1c2d509..f2d5a2e80 100644
--- a/shipping-service/pom.xml
+++ b/shipping-service/pom.xml
@@ -69,10 +69,27 @@
true
- org.testcontainers
- mysql
- test
-
+ org.testcontainers
+ mysql
+ test
+
+
+ org.springframework.boot
+ spring-boot-starter-actuator
+
+
+ io.micrometer
+ micrometer-registry-prometheus
+
+
+ net.logstash.logback
+ logstash-logback-encoder
+ 7.3
+
+
+ org.springframework.cloud
+ spring-cloud-starter-sleuth
+
diff --git a/shipping-service/src/main/java/com/selimhorri/app/service/impl/OrderItemServiceImpl.java b/shipping-service/src/main/java/com/selimhorri/app/service/impl/OrderItemServiceImpl.java
index 8a6605ad9..cd8f1a88c 100644
--- a/shipping-service/src/main/java/com/selimhorri/app/service/impl/OrderItemServiceImpl.java
+++ b/shipping-service/src/main/java/com/selimhorri/app/service/impl/OrderItemServiceImpl.java
@@ -49,8 +49,8 @@ public List findAll() {
@Override
public OrderItemDto findById(final OrderItemId orderItemId) {
- log.info("*** OrderItemDto, service; fetch orderItem by id *");
- return this.orderItemRepository.findById(null)
+ log.info("*** OrderItemDto, service; fetch orderItem by id *", orderItemId);
+ return this.orderItemRepository.findById(orderItemId)
.map(OrderItemMappingHelper::map)
.map(o -> {
o.setProductDto(this.restTemplate.getForObject(AppConstant.DiscoveredDomainsApi
@@ -59,7 +59,10 @@ public OrderItemDto findById(final OrderItemId orderItemId) {
.ORDER_SERVICE_API_URL + "/" + o.getOrderDto().getOrderId(), OrderDto.class));
return o;
})
- .orElseThrow(() -> new OrderItemNotFoundException(String.format("OrderItem with id: %s not found", orderItemId)));
+ .orElseThrow(() -> {
+ log.warn("OrderItem not found for id: {}", orderItemId);
+ throw new OrderItemNotFoundException(String.format("OrderItem with id: %s not found", orderItemId));
+ });
}
@Override
diff --git a/shipping-service/src/main/resources/application.yml b/shipping-service/src/main/resources/application.yml
index a7230f2ae..14eda8272 100644
--- a/shipping-service/src/main/resources/application.yml
+++ b/shipping-service/src/main/resources/application.yml
@@ -5,15 +5,21 @@ server:
spring:
zipkin:
- base-url: ${SPRING_ZIPKIN_BASE_URL:http://localhost:9411/}
+ base-url: ${SPRING_ZIPKIN_BASE_URL:http://zipkin:9411/}
config:
- import: ${SPRING_CONFIG_IMPORT:optional:configserver:http://localhost:9296}
+ import: ${SPRING_CONFIG_IMPORT:optional:configserver:http://cloud-config:9296}
application:
name: SHIPPING-SERVICE
profiles:
active:
- dev
+eureka:
+ client:
+ service-url:
+ defaultZone: ${EUREKA_CLIENT_SERVICEURL_DEFAULTZONE:http://service-discovery-container:8761/eureka/}
+
+
resilience4j:
circuitbreaker:
instances:
@@ -29,12 +35,33 @@ resilience4j:
sliding-window-type: COUNT_BASED
management:
- health:
- circuitbreakers:
- enabled: true
+ endpoints:
+ web:
+ exposure:
+ include: health,info,metrics,prometheus,env,loggers,threaddump,heapdump
endpoint:
health:
show-details: always
+ probes:
+ enabled: true
+ metrics:
+ enabled: true
+ prometheus:
+ enabled: true
+ metrics:
+ export:
+ prometheus:
+ enabled: true
+ tags:
+ application: ${spring.application.name}
+ environment: ${spring.profiles.active}
+ health:
+ circuitbreakers:
+ enabled: true
+ livenessstate:
+ enabled: true
+ readinessstate:
+ enabled: true
diff --git a/shipping-service/src/main/resources/logback-spring.xml b/shipping-service/src/main/resources/logback-spring.xml
new file mode 100644
index 000000000..9a551a487
--- /dev/null
+++ b/shipping-service/src/main/resources/logback-spring.xml
@@ -0,0 +1,46 @@
+
+
+
+
+
+
+
+
+
+
+ {"app_name":"${appName}","app_port":"${appPort}"}
+ traceId
+ spanId
+
+
+
+
+
+ logstash:5000
+
+ {"app_name":"${appName}","app_port":"${appPort}"}
+ traceId
+ spanId
+
+ 5 minutes
+
+
+
+
+
+ 512
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/shipping-service/src/test/java/com/selimhorri/app/integration/ShippingServiceApplicationIntegrationTest.java b/shipping-service/src/test/java/com/selimhorri/app/integration/ShippingServiceApplicationIntegrationTest.java
new file mode 100644
index 000000000..a5fab8aff
--- /dev/null
+++ b/shipping-service/src/test/java/com/selimhorri/app/integration/ShippingServiceApplicationIntegrationTest.java
@@ -0,0 +1,44 @@
+package com.selimhorri.app.integration;
+
+import com.selimhorri.app.ShippingServiceApplication;
+import com.selimhorri.app.config.mapper.MapperConfig;
+import com.selimhorri.app.config.client.ClientConfig;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.jupiter.api.Test;
+import org.springframework.web.client.RestTemplate;
+import org.springframework.boot.test.context.SpringBootTest;
+import static org.junit.jupiter.api.Assertions.*;
+
+@SpringBootTest
+public class ShippingServiceApplicationIntegrationTest {
+
+ @Test
+ void contextLoads() {
+ // Spring context should load without exceptions
+ }
+
+ @Test
+ void testObjectMapperBean() {
+ MapperConfig config = new MapperConfig();
+ ObjectMapper mapper = config.objectMapperBean();
+ assertNotNull(mapper);
+ assertTrue(mapper.isEnabled(com.fasterxml.jackson.databind.SerializationFeature.INDENT_OUTPUT));
+ }
+
+ @Test
+ void testRestTemplateBean() {
+ ClientConfig config = new ClientConfig();
+ RestTemplate restTemplate = config.restTemplateBean();
+ assertNotNull(restTemplate);
+ }
+
+ @Test
+ void testMainMethodDoesNotThrow() {
+ assertDoesNotThrow(() -> ShippingServiceApplication.main(new String[]{}));
+ }
+
+ @Test
+ void testApplicationClassIsNotNull() {
+ assertNotNull(ShippingServiceApplication.class);
+ }
+}
diff --git a/shipping-service/src/test/java/com/selimhorri/app/unit/ShippingServiceApplicationUnitTest.java b/shipping-service/src/test/java/com/selimhorri/app/unit/ShippingServiceApplicationUnitTest.java
new file mode 100644
index 000000000..fcf3f8fcc
--- /dev/null
+++ b/shipping-service/src/test/java/com/selimhorri/app/unit/ShippingServiceApplicationUnitTest.java
@@ -0,0 +1,59 @@
+package com.selimhorri.app.unit;
+
+import com.selimhorri.app.ShippingServiceApplication;
+import com.selimhorri.app.helper.OrderItemMappingHelper;
+import com.selimhorri.app.domain.OrderItem;
+import com.selimhorri.app.dto.OrderItemDto;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class ShippingServiceApplicationUnitTest {
+
+ @Test
+ void testMainMethodExists() {
+ try {
+ java.lang.reflect.Method main = ShippingServiceApplication.class.getMethod("main", String[].class);
+ int modifiers = main.getModifiers();
+ assertTrue(java.lang.reflect.Modifier.isPublic(modifiers));
+ assertTrue(java.lang.reflect.Modifier.isStatic(modifiers));
+ } catch (NoSuchMethodException e) {
+ fail("main method not found");
+ }
+ }
+
+ @Test
+ void testOrderItemMappingHelperMapToDto() {
+ OrderItem orderItem = OrderItem.builder().productId(1).orderId(2).orderedQuantity(3).build();
+ OrderItemDto dto = OrderItemMappingHelper.map(orderItem);
+ assertEquals(1, dto.getProductId());
+ assertEquals(2, dto.getOrderId());
+ assertEquals(3, dto.getOrderedQuantity());
+ assertNotNull(dto.getProductDto());
+ assertNotNull(dto.getOrderDto());
+ }
+
+ @Test
+ void testOrderItemMappingHelperMapToEntity() {
+ OrderItemDto dto = OrderItemDto.builder().productId(1).orderId(2).orderedQuantity(3).build();
+ OrderItem entity = OrderItemMappingHelper.map(dto);
+ assertEquals(1, entity.getProductId());
+ assertEquals(2, entity.getOrderId());
+ assertEquals(3, entity.getOrderedQuantity());
+ }
+
+ @Test
+ void testOrderItemDtoBuilder() {
+ OrderItemDto dto = OrderItemDto.builder().productId(10).orderId(20).orderedQuantity(30).build();
+ assertEquals(10, dto.getProductId());
+ assertEquals(20, dto.getOrderId());
+ assertEquals(30, dto.getOrderedQuantity());
+ }
+
+ @Test
+ void testOrderItemBuilder() {
+ OrderItem entity = OrderItem.builder().productId(10).orderId(20).orderedQuantity(30).build();
+ assertEquals(10, entity.getProductId());
+ assertEquals(20, entity.getOrderId());
+ assertEquals(30, entity.getOrderedQuantity());
+ }
+}
diff --git a/user-service/Dockerfile b/user-service/Dockerfile
index fdc109e11..4e7aa5a30 100644
--- a/user-service/Dockerfile
+++ b/user-service/Dockerfile
@@ -3,10 +3,8 @@ FROM openjdk:11
ARG PROJECT_VERSION=0.1.0
RUN mkdir -p /home/app
WORKDIR /home/app
-ENV SPRING_PROFILES_ACTIVE dev
+ENV SPRING_PROFILES_ACTIVE=dev
COPY user-service/ .
ADD user-service/target/user-service-v${PROJECT_VERSION}.jar user-service.jar
EXPOSE 8700
-ENTRYPOINT ["java", "-Dspring.profiles.active=${SPRING_PROFILES_ACTIVE}", "-jar", "user-service.jar"]
-
-
+ENTRYPOINT ["java", "-Dspring.profiles.active=${SPRING_PROFILES_ACTIVE}", "-jar", "user-service.jar"]
\ No newline at end of file
diff --git a/user-service/compose.yml b/user-service/compose.yml
index 18c0f49a0..87cd3aeba 100644
--- a/user-service/compose.yml
+++ b/user-service/compose.yml
@@ -1,12 +1,21 @@
-
+#docker-compose
version: '3'
services:
user-service-container:
- image: selimhorri/user-service-ecommerce-boot:0.1.0
+ image: juanse201/user-service-ecommerce-boot:0.1.0
ports:
- 8700:8700
environment:
- SPRING_PROFILES_ACTIVE=dev
-
-
-
+ - SPRING_ZIPKIN_BASE_URL=http://zipkin:9411
+ - SPRING_CONFIG_IMPORT=optional:configserver:http://cloud-config-container:9296/
+ - EUREKA_CLIENT_REGION=default
+ - EUREKA_CLIENT_AVAILABILITY_ZONES_DEFAULT=myzone
+ - EUREKA_CLIENT_SERVICEURL_MYZONE=http://service-discovery-container:8761/eureka
+ - EUREKA_CLIENT_SERVICEURL_DEFAULTZONE=http://service-discovery-container:8761/eureka/
+ networks:
+ - microservices_network
+networks:
+ microservices_network:
+ external: true
+ name: microservices_network
diff --git a/user-service/pom.xml b/user-service/pom.xml
index 28bed9bd3..7206edd9a 100644
--- a/user-service/pom.xml
+++ b/user-service/pom.xml
@@ -73,6 +73,23 @@
mysql
test
+
+ org.springframework.boot
+ spring-boot-starter-actuator
+
+
+ io.micrometer
+ micrometer-registry-prometheus
+
+
+ net.logstash.logback
+ logstash-logback-encoder
+ 7.3
+
+
+ org.springframework.cloud
+ spring-cloud-starter-sleuth
+
diff --git a/user-service/src/main/java/com/selimhorri/app/helper/UserMappingHelper.java b/user-service/src/main/java/com/selimhorri/app/helper/UserMappingHelper.java
index 1bb02c2d6..d26fda2fc 100644
--- a/user-service/src/main/java/com/selimhorri/app/helper/UserMappingHelper.java
+++ b/user-service/src/main/java/com/selimhorri/app/helper/UserMappingHelper.java
@@ -8,47 +8,59 @@
public interface UserMappingHelper {
public static UserDto map(final User user) {
- return UserDto.builder()
- .userId(user.getUserId())
- .firstName(user.getFirstName())
- .lastName(user.getLastName())
- .imageUrl(user.getImageUrl())
- .email(user.getEmail())
- .phone(user.getPhone())
- .credentialDto(
- CredentialDto.builder()
- .credentialId(user.getCredential().getCredentialId())
- .username(user.getCredential().getUsername())
- .password(user.getCredential().getPassword())
- .roleBasedAuthority(user.getCredential().getRoleBasedAuthority())
- .isEnabled(user.getCredential().getIsEnabled())
- .isAccountNonExpired(user.getCredential().getIsAccountNonExpired())
- .isAccountNonLocked(user.getCredential().getIsAccountNonLocked())
- .isCredentialsNonExpired(user.getCredential().getIsCredentialsNonExpired())
- .build())
- .build();
+ Credential credential = user.getCredential();
+ CredentialDto credentialDto = null;
+ if (credential != null) {
+ credentialDto = CredentialDto.builder()
+ .credentialId(credential.getCredentialId())
+ .username(credential.getUsername())
+ .password(credential.getPassword())
+ .roleBasedAuthority(credential.getRoleBasedAuthority())
+ .isEnabled(credential.getIsEnabled())
+ .isAccountNonExpired(credential.getIsAccountNonExpired())
+ .isAccountNonLocked(credential.getIsAccountNonLocked())
+ .isCredentialsNonExpired(credential.getIsCredentialsNonExpired())
+ .build();
+ }
+ return UserDto.builder()
+ .userId(user.getUserId())
+ .firstName(user.getFirstName())
+ .lastName(user.getLastName())
+ .imageUrl(user.getImageUrl())
+ .email(user.getEmail())
+ .phone(user.getPhone())
+ .credentialDto(credentialDto)
+ .build();
}
public static User map(final UserDto userDto) {
- return User.builder()
- .userId(userDto.getUserId())
- .firstName(userDto.getFirstName())
- .lastName(userDto.getLastName())
- .imageUrl(userDto.getImageUrl())
- .email(userDto.getEmail())
- .phone(userDto.getPhone())
- .credential(
- Credential.builder()
- .credentialId(userDto.getCredentialDto().getCredentialId())
- .username(userDto.getCredentialDto().getUsername())
- .password(userDto.getCredentialDto().getPassword())
- .roleBasedAuthority(userDto.getCredentialDto().getRoleBasedAuthority())
- .isEnabled(userDto.getCredentialDto().getIsEnabled())
- .isAccountNonExpired(userDto.getCredentialDto().getIsAccountNonExpired())
- .isAccountNonLocked(userDto.getCredentialDto().getIsAccountNonLocked())
- .isCredentialsNonExpired(userDto.getCredentialDto().getIsCredentialsNonExpired())
- .build())
- .build();
+ User.UserBuilder userBuilder = User.builder()
+ .userId(userDto.getUserId())
+ .firstName(userDto.getFirstName())
+ .lastName(userDto.getLastName())
+ .imageUrl(userDto.getImageUrl())
+ .email(userDto.getEmail())
+ .phone(userDto.getPhone());
+
+ if (userDto.getCredentialDto() != null) {
+ Credential.CredentialBuilder credentialBuilder = Credential.builder()
+ .credentialId(userDto.getCredentialDto().getCredentialId())
+ .username(userDto.getCredentialDto().getUsername())
+ .password(userDto.getCredentialDto().getPassword())
+ .roleBasedAuthority(userDto.getCredentialDto().getRoleBasedAuthority())
+ .isEnabled(userDto.getCredentialDto().getIsEnabled())
+ .isAccountNonExpired(userDto.getCredentialDto().getIsAccountNonExpired())
+ .isAccountNonLocked(userDto.getCredentialDto().getIsAccountNonLocked())
+ .isCredentialsNonExpired(userDto.getCredentialDto().getIsCredentialsNonExpired());
+
+ Credential credential = credentialBuilder.build();
+ User user = userBuilder.build();
+ credential.setUser(user);
+ user.setCredential(credential);
+ return user;
+ } else {
+ return userBuilder.build();
+ }
}
diff --git a/user-service/src/main/resources/application.yml b/user-service/src/main/resources/application.yml
index 27596cdd2..da7663a31 100644
--- a/user-service/src/main/resources/application.yml
+++ b/user-service/src/main/resources/application.yml
@@ -5,15 +5,20 @@ server:
spring:
zipkin:
- base-url: ${SPRING_ZIPKIN_BASE_URL:http://localhost:9411/}
+ base-url: ${SPRING_ZIPKIN_BASE_URL:http://zipkin:9411/}
config:
- import: ${SPRING_CONFIG_IMPORT:optional:configserver:http://localhost:9296}
+ import: ${SPRING_CONFIG_IMPORT:optional:configserver:http://cloud-config:9296}
application:
name: USER-SERVICE
profiles:
active:
- dev
+eureka:
+ client:
+ service-url:
+ defaultZone: ${EUREKA_CLIENT_SERVICEURL_DEFAULTZONE:http://service-discovery-container:8761/eureka/}
+
resilience4j:
circuitbreaker:
instances:
@@ -29,12 +34,33 @@ resilience4j:
sliding-window-type: COUNT_BASED
management:
- health:
- circuitbreakers:
- enabled: true
+ endpoints:
+ web:
+ exposure:
+ include: health,info,metrics,prometheus,env,loggers,threaddump,heapdump
endpoint:
health:
show-details: always
+ probes:
+ enabled: true
+ metrics:
+ enabled: true
+ prometheus:
+ enabled: true
+ metrics:
+ export:
+ prometheus:
+ enabled: true
+ tags:
+ application: ${spring.application.name}
+ environment: ${spring.profiles.active}
+ health:
+ circuitbreakers:
+ enabled: true
+ livenessstate:
+ enabled: true
+ readinessstate:
+ enabled: true
diff --git a/user-service/src/main/resources/logback-spring.xml b/user-service/src/main/resources/logback-spring.xml
new file mode 100644
index 000000000..9a551a487
--- /dev/null
+++ b/user-service/src/main/resources/logback-spring.xml
@@ -0,0 +1,46 @@
+
+
+
+
+
+
+
+
+
+
+ {"app_name":"${appName}","app_port":"${appPort}"}
+ traceId
+ spanId
+
+
+
+
+
+ logstash:5000
+
+ {"app_name":"${appName}","app_port":"${appPort}"}
+ traceId
+ spanId
+
+ 5 minutes
+
+
+
+
+
+ 512
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/user-service/src/test/java/com/selimhorri/app/integration/UserServiceApplicationIntegrationTest.java b/user-service/src/test/java/com/selimhorri/app/integration/UserServiceApplicationIntegrationTest.java
new file mode 100644
index 000000000..487d583d7
--- /dev/null
+++ b/user-service/src/test/java/com/selimhorri/app/integration/UserServiceApplicationIntegrationTest.java
@@ -0,0 +1,44 @@
+package com.selimhorri.app.integration;
+
+import com.selimhorri.app.UserServiceApplication;
+import com.selimhorri.app.helper.UserMappingHelper;
+import com.selimhorri.app.dto.UserDto;
+import com.selimhorri.app.dto.CredentialDto;
+import com.selimhorri.app.domain.User;
+import com.selimhorri.app.domain.Credential;
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
+import static org.junit.jupiter.api.Assertions.*;
+
+@SpringBootTest
+public class UserServiceApplicationIntegrationTest {
+
+ @Test
+ void contextLoads() {
+ // Spring context should load without exceptions
+ }
+
+ @Test
+ void testUserMappingHelperMapToDtoAndBack() {
+ Credential cred = Credential.builder().credentialId(1).username("user").password("pass").build();
+ User user = User.builder().userId(2).firstName("A").lastName("B").email("a@b.com").credential(cred).build();
+ UserDto dto = UserMappingHelper.map(user);
+ User user2 = UserMappingHelper.map(dto);
+ assertEquals(user.getUserId(), user2.getUserId());
+ assertEquals(user.getFirstName(), user2.getFirstName());
+ assertEquals(user.getCredential().getUsername(), user2.getCredential().getUsername());
+ }
+
+ @Test
+ void testUserDtoBuilderWithCredential() {
+ CredentialDto cred = CredentialDto.builder().credentialId(1).username("user").password("pass").build();
+ UserDto dto = UserDto.builder().userId(2).credentialDto(cred).build();
+ assertEquals(2, dto.getUserId());
+ assertEquals("user", dto.getCredentialDto().getUsername());
+ }
+
+ @Test
+ void testApplicationClassIsNotNull() {
+ assertNotNull(UserServiceApplication.class);
+ }
+}
diff --git a/user-service/src/test/java/com/selimhorri/app/unit/UserServiceApplicationUnitTest.java b/user-service/src/test/java/com/selimhorri/app/unit/UserServiceApplicationUnitTest.java
new file mode 100644
index 000000000..c01878d74
--- /dev/null
+++ b/user-service/src/test/java/com/selimhorri/app/unit/UserServiceApplicationUnitTest.java
@@ -0,0 +1,64 @@
+package com.selimhorri.app.unit;
+
+import com.selimhorri.app.UserServiceApplication;
+import com.selimhorri.app.helper.UserMappingHelper;
+import com.selimhorri.app.dto.UserDto;
+import com.selimhorri.app.dto.CredentialDto;
+import com.selimhorri.app.domain.User;
+import com.selimhorri.app.domain.Credential;
+import com.selimhorri.app.dto.AddressDto;
+import org.junit.jupiter.api.Test;
+import java.util.Set;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class UserServiceApplicationUnitTest {
+
+ @Test
+ void testMainMethodExists() {
+ try {
+ java.lang.reflect.Method main = UserServiceApplication.class.getMethod("main", String[].class);
+ int modifiers = main.getModifiers();
+ assertTrue(java.lang.reflect.Modifier.isPublic(modifiers));
+ assertTrue(java.lang.reflect.Modifier.isStatic(modifiers));
+ } catch (NoSuchMethodException e) {
+ fail("main method not found");
+ }
+ }
+
+ @Test
+ void testUserMappingHelperMapToDto() {
+ Credential cred = Credential.builder().credentialId(1).username("user").password("pass").build();
+ User user = User.builder().userId(2).firstName("A").lastName("B").email("a@b.com").credential(cred).build();
+ UserDto dto = UserMappingHelper.map(user);
+ assertEquals(2, dto.getUserId());
+ assertEquals("A", dto.getFirstName());
+ assertEquals("user", dto.getCredentialDto().getUsername());
+ }
+
+ @Test
+ void testUserMappingHelperMapToEntity() {
+ CredentialDto cred = CredentialDto.builder().credentialId(1).username("user").password("pass").build();
+ UserDto dto = UserDto.builder().userId(2).firstName("A").lastName("B").email("a@b.com").credentialDto(cred).build();
+ User user = UserMappingHelper.map(dto);
+ assertEquals(2, user.getUserId());
+ assertEquals("A", user.getFirstName());
+ assertEquals("user", user.getCredential().getUsername());
+ }
+
+ @Test
+ void testUserDtoBuilder() {
+ UserDto dto = UserDto.builder().userId(10).firstName("F").lastName("L").email("f@l.com").build();
+ assertEquals(10, dto.getUserId());
+ assertEquals("F", dto.getFirstName());
+ assertEquals("L", dto.getLastName());
+ assertEquals("f@l.com", dto.getEmail());
+ }
+
+ @Test
+ void testUserDtoWithAddresses() {
+ AddressDto address = new AddressDto();
+ UserDto dto = UserDto.builder().userId(1).addressDtos(Set.of(address)).build();
+ assertNotNull(dto.getAddressDtos());
+ assertEquals(1, dto.getAddressDtos().size());
+ }
+}