removes tracing and redundant code

Signed-off-by: Elena Kolevska <[email protected]>

Author: elena-kolevska

.env.example

@@ -56,7 +56,7 @@ OTEL_SERVICE_VERSION=1.0.0
 OTEL_EXPORTER_OTLP_ENDPOINT=
 OTEL_EXPORTER_OTLP_HEADERS=
 OTEL_EXPORTER_OTLP_TIMEOUT=10
-OTEL_EXPORTER_JAEGER_ENDPOINT=
+
 OTEL_RESOURCE_ATTRIBUTES=service.name=redis-py-test-app,service.version=1.0.0
 
 # Multi-App Identification

README.md

@@ -31,7 +31,6 @@ python main.py run --workload-profile basic_rw # unlimited test run
 **Access your dashboards:**
 - **📊 Grafana**: http://localhost:3000 (admin/admin) - **Redis Test Dashboard**
 - **📈 Prometheus**: http://localhost:9090 - Raw metrics
-- **🔍 Jaeger**: http://localhost:16686 - Distributed tracing
 
 ### 🐳 Full Docker Environment
 
@@ -44,7 +43,7 @@ python main.py run --workload-profile basic_rw # unlimited test run
 This single command will:
 - Build the Redis test application
 - Start Redis database
-- Launch complete monitoring stack (Prometheus, Grafana, Jaeger)
+- Launch complete monitoring stack (Prometheus, Grafana)
 - Begin running performance tests
 
 **Management commands:**
@@ -71,7 +70,7 @@ make dev-start
 ```
 
 This will:
-- Start metrics stack (Redis, Prometheus, Grafana, Jaeger) in Docker
+- Start metrics stack (Redis, Prometheus, Grafana) in Docker
 - Install Python dependencies in virtual environment
 - Configure local environment (.env file)
 - Test the connection
@@ -88,7 +87,6 @@ make dev-start-metrics-stack
 ### Access Services
 - **📊 Grafana**: http://localhost:3000 (admin/admin) - **Redis Test Dashboard**
 - **📈 Prometheus**: http://localhost:9090 - Raw metrics and queries
-- **🔍 Jaeger**: http://localhost:16686 - Distributed tracing
 - **📡 Redis**: localhost:6379 - Database connection
 
 ### Development Workflow
@@ -474,7 +472,6 @@ make deploy-prod   # Production environment
 ### **Monitoring Stack:**
 - **Prometheus** - Metrics collection
 - **Grafana** - Dashboards and visualization
-- **Jaeger** - Distributed tracing
 - **OpenTelemetry** - Observability framework
 
 **📋 TODO Items:**

cli.py

@@ -213,7 +213,7 @@ def test_connection():
         client = RedisClientManager(redis_config)
 
         # Test basic operations
-        client.execute_command('ping')
+        client.ping()
         info = client.get_info()
 
         click.echo("✓ Redis connection successful!")

diagrams/class-diagram.md

@@ -128,7 +128,7 @@ classDiagram
         +publish(channel: str, message: str) int
         +pubsub() PubSub
         +pipeline() Pipeline
-        +execute_command(command: str, *args) Any
+
         +ping() bool
         +close() void
     }
@@ -272,7 +272,7 @@ classDiagram
         +record_connection_attempt(success: bool) void
         +record_reconnection(duration: float) void
         +update_active_connections(count: int) void
-        +update_calculated_metrics() void
+
         +get_stats() Dict[str,Any]
         +get_detailed_stats() Dict[str,Any]
         +reset_stats() void

docker-compose.metrics.yml

@@ -30,10 +30,9 @@ services:
       - "4317:4317"   # OTLP gRPC receiver
       - "4318:4318"   # OTLP HTTP receiver
       - "8889:8889"   # Prometheus metrics endpoint
-      - "14250:14250" # Jaeger gRPC
+
     depends_on:
       - prometheus
-      - jaeger
     networks:
       - redis-test-network
 
@@ -74,17 +73,7 @@ services:
     networks:
       - redis-test-network
 
-  # Jaeger
-  jaeger:
-    image: jaegertracing/all-in-one:latest
-    container_name: jaeger
-    environment:
-      - COLLECTOR_OTLP_ENABLED=true
-    ports:
-      - "16686:16686"  # Jaeger UI
-      - "14268:14268"  # Jaeger collector HTTP
-    networks:
-      - redis-test-network
+
 
 networks:
   redis-test-network:

docker-compose.yml

@@ -122,9 +122,8 @@ services:
       - "4317:4317"   # OTLP gRPC receiver
       - "4318:4318"   # OTLP HTTP receiver
       - "8889:8889"   # Prometheus metrics
-      - "14250:14250" # Jaeger gRPC
+
     depends_on:
-      - jaeger
       - prometheus
     networks:
       - redis-test-network
@@ -166,17 +165,7 @@ services:
     networks:
       - redis-test-network
 
-  # Jaeger
-  jaeger:
-    image: jaegertracing/all-in-one:latest
-    container_name: jaeger
-    ports:
-      - "16686:16686"  # Jaeger UI
-      - "14268:14268"  # Jaeger HTTP
-    environment:
-      - COLLECTOR_OTLP_ENABLED=true
-    networks:
-      - redis-test-network
+
 
 volumes:
   redis_data:

metrics.py

@@ -12,19 +12,15 @@
 import uuid
 
 # Prometheus imports (for backward compatibility)
-from prometheus_client import Counter, Histogram, Gauge, start_http_server
+from prometheus_client import Counter, Histogram, Gauge
 
 # OpenTelemetry imports
 from opentelemetry import metrics as otel_metrics
-from opentelemetry import trace as otel_trace
 from opentelemetry.sdk.metrics import MeterProvider
-from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.resources import Resource
 from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter
-from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
 from opentelemetry.exporter.prometheus import PrometheusMetricReader
 from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
-from opentelemetry.sdk.trace.export import BatchSpanProcessor
 # Note: RedisInstrumentor import removed to prevent automatic instrumentation
 
 from logger import get_logger
@@ -136,18 +132,7 @@ def _setup_opentelemetry(self):
                 unit="1"
             )
 
-            # Setup tracing
-            if self.otel_endpoint:
-                trace_exporter = OTLPSpanExporter(
-                    endpoint=self.otel_endpoint,
-                    insecure=True
-                )
-                trace_provider = TracerProvider(resource=resource)
-                trace_provider.add_span_processor(
-                    BatchSpanProcessor(trace_exporter)
-                )
-                otel_trace.set_tracer_provider(trace_provider)
-                self.tracer = otel_trace.get_tracer(self.service_name, self.service_version)
+
 
             # Note: Using manual instrumentation instead of automatic Redis instrumentation
             # to have full control over operation labeling and avoid "BATCH" aggregation
@@ -214,14 +199,7 @@ def _setup_prometheus_metrics(self):
             ['operation'] + base_labels
         )
 
-    def _start_prometheus_server(self):
-        """Start Prometheus metrics server."""
-        try:
-            start_http_server(self.prometheus_port)
-            self.logger.info(f"Prometheus metrics server started on port {self.prometheus_port}")
-        except Exception as e:
-            self.logger.error(f"Failed to start Prometheus server: {e}")
-            self.enable_prometheus = False
+
 
     def record_operation(self, operation: str, duration: float, success: bool, error_type: str = None):
         """Record metrics for a Redis operation."""
@@ -318,50 +296,9 @@ def update_active_connections(self, count: int):
 
         # Active connections tracked via OpenTelemetry only
 
-    def update_calculated_metrics(self):
-        """Update calculated metrics like throughput, error rate, and average latency."""
-        if not self.enable_otel:
-            return
 
-        with self._lock:
-            # Calculate overall throughput and error rate
-            total_ops = sum(m.total_count for m in self._metrics.values())
-            total_errors = sum(m.error_count for m in self._metrics.values())
 
-            if total_ops > 0:
-                # Calculate current throughput (ops in last interval)
-                current_time = time.time()
-                if hasattr(self, '_last_metrics_update'):
-                    time_diff = current_time - self._last_metrics_update
-                    if time_diff > 0:
-                        ops_diff = total_ops - getattr(self, '_last_total_ops', 0)
-                        current_throughput = ops_diff / time_diff
-                        # Calculated metrics are now handled by the OpenTelemetry Collector
-                        # which exposes them via its Prometheus endpoint
-
-                # Error rate and average latency calculations
-                error_rate = (total_errors / total_ops) * 100
-                # These calculated metrics are available via the collector's Prometheus endpoint
-
-            # Store for next calculation
-            self._last_metrics_update = current_time
-            self._last_total_ops = total_ops
-
-    def create_span(self, operation_name: str, **attributes):
-        """Create an OpenTelemetry span for tracing Redis operations."""
-        if self.enable_otel and hasattr(self, 'tracer'):
-            return self.tracer.start_span(
-                name=f"redis.{operation_name}",
-                attributes={
-                    "db.system": "redis",
-                    "db.operation": operation_name,
-                    **attributes
-                }
-            )
-        else:
-            # Return a no-op context manager if OpenTelemetry is not enabled
-            from contextlib import nullcontext
-            return nullcontext()
+
 
     def get_operation_stats(self, operation: str) -> Dict:
         """Get statistics for a specific operation."""

observability/otel-collector-config.yml

@@ -22,22 +22,15 @@ exporters:
     endpoint: "0.0.0.0:8889"
     # Remove const_labels to avoid duplication
 
-  # OTLP exporter for Jaeger (using internal Docker network)
-  otlp/jaeger:
-    endpoint: jaeger:4317
-    tls:
-      insecure: true
+
 
   # Debug exporter for debugging (replaces deprecated logging exporter)
   debug:
     verbosity: normal
 
 service:
   pipelines:
-    traces:
-      receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp/jaeger, debug]
+
 
     metrics:
       receivers: [otlp]

redis_client.py

@@ -183,93 +183,7 @@ def _reconnect(self) -> bool:
         self.logger.error(f"Failed to reconnect after {self.config.retry_attempts} attempts")
         return False
 
-    def execute_command(self, command: str, *args, **kwargs) -> Any:
-        """Execute a Redis command with automatic retry and error handling."""
-        if not self._ensure_connection():
-            raise ConnectionError("No Redis connection available")
-
-        start_time = time.time()
-        last_exception = None
-
-        # Create OpenTelemetry span for tracing
-        with self.metrics.create_span(
-            command,
-            db_statement=f"{command} {' '.join(str(arg) for arg in args[:2])}",  # Limit args for privacy
-            db_redis_database_index=self.config.database
-        ) as span:
-            for attempt in range(self.config.retry_attempts):
-                try:
-                    # Execute the command
-                    result = getattr(self._client, command.lower())(*args, **kwargs)
-
-                    # Record successful operation
-                    duration = time.time() - start_time
-                    self.metrics.record_operation(command, duration, True)
-
-                    # Update span with success
-                    if span and hasattr(span, 'set_status'):
-                        from opentelemetry.trace import Status, StatusCode
-                        span.set_status(Status(StatusCode.OK))
-                        span.set_attribute("db.operation.success", True)
-
-                    return result
-
-                except (ConnectionError, TimeoutError, ClusterDownError) as e:
-                    last_exception = e
-                    self.logger.warning(f"Connection error during {command}: {e}")
-
-                    # Update span with error
-                    if span and hasattr(span, 'record_exception'):
-                        span.record_exception(e)
-                        span.set_attribute("db.operation.success", False)
-                        span.set_attribute("error.type", type(e).__name__)
-
-                    # Try to reconnect
-                    if not self._reconnect():
-                        break
-
-                except (ResponseError, RedisError) as e:
-                    # Redis-level errors (don't retry)
-                    duration = time.time() - start_time
-                    error_type = type(e).__name__
-                    self.metrics.record_operation(command, duration, False, error_type)
-
-                    # Update span with error
-                    if span and hasattr(span, 'record_exception'):
-                        span.record_exception(e)
-                        span.set_attribute("db.operation.success", False)
-                        span.set_attribute("error.type", error_type)
-
-                    raise e
-
-                except Exception as e:
-                    # Unexpected errors
-                    duration = time.time() - start_time
-                    error_type = type(e).__name__
-                    self.metrics.record_operation(command, duration, False, error_type)
-                    log_error_with_traceback(f"Unexpected error during {command}", e)
-
-                    # Update span with error
-                    if span and hasattr(span, 'record_exception'):
-                        span.record_exception(e)
-                        span.set_attribute("db.operation.success", False)
-                        span.set_attribute("error.type", error_type)
-
-                    raise e
-        
-            # All retry attempts failed
-            duration = time.time() - start_time
-            error_type = type(last_exception).__name__ if last_exception else "ConnectionError"
-            self.metrics.record_operation(command, duration, False, error_type)
-
-            # Update span with final error
-            if span and hasattr(span, 'record_exception') and last_exception:
-                span.record_exception(last_exception)
-                span.set_attribute("db.operation.success", False)
-                span.set_attribute("error.type", error_type)
-                span.set_attribute("retry.attempts", self.config.retry_attempts)
 
-            raise last_exception or ConnectionError("Failed to execute command after retries")
 
     def pipeline(self, transaction: bool = True):
         """Create a pipeline for batch operations."""