fix: resolve linting and CI issues - Fix ruff violations, improve OpenTelemetry config for CI, remove unused imports, update type annotations

Author: alvidofaisal

backend/app/api/main.py

@@ -1,6 +1,6 @@
 from fastapi import APIRouter
 
-from app.api.routes import items, login, private, users, utils, analytics
+from app.api.routes import analytics, items, login, private, users, utils
 from app.core.config import settings
 
 api_router = APIRouter()

backend/app/api/routes/analytics.py

@@ -1,53 +1,60 @@
-from fastapi import APIRouter, Depends, HTTPException
-from sqlmodel import Session, select
-import polars as pl
-from typing import List, Dict, Any # Dict and Any might be needed for Polars conversion
 from datetime import date
-import pydantic # Ensure pydantic is imported
-
-from app.models import User, Item # Assuming User model is in app.models, Import Item
-from app.api.deps import SessionDep, get_current_active_superuser # SessionDep for dependency injection
 
+import polars as pl
+import pydantic  # Ensure pydantic is imported
+from fastapi import APIRouter
 from opentelemetry import trace
+from sqlmodel import select
+
+from app.api.deps import SessionDep  # SessionDep for dependency injection
+from app.models import Item, User  # Assuming User model is in app.models, Import Item
+
 
 # Pydantic models for response
-class UserSignupTrend(pydantic.BaseModel): # Corrected: pydantic.BaseModel
-    signup_date: date 
+class UserSignupTrend(pydantic.BaseModel):  # Corrected: pydantic.BaseModel
+    signup_date: date
     count: int
 
-class UserActivity(pydantic.BaseModel): # Corrected: pydantic.BaseModel
+
+class UserActivity(pydantic.BaseModel):  # Corrected: pydantic.BaseModel
     active_users: int
     inactive_users: int
 
-class UserAnalyticsSummary(pydantic.BaseModel): # Corrected: pydantic.BaseModel
+
+class UserAnalyticsSummary(pydantic.BaseModel):  # Corrected: pydantic.BaseModel
     total_users: int
-    signup_trends: List[UserSignupTrend]
+    signup_trends: list[UserSignupTrend]
     activity_summary: UserActivity
     # Add more fields as desired, e.g., average_items_per_user: float
 
+
 # Pydantic models for Item analytics
 class ItemCreationTrend(pydantic.BaseModel):
     creation_date: date
     count: int
 
+
 # class ItemOwnerDistribution(pydantic.BaseModel): # Optional for now
-#     owner_id: str 
+#     owner_id: str
 #     item_count: int
 
+
 class ItemAnalyticsTrends(pydantic.BaseModel):
     total_items: int
-    creation_trends: List[ItemCreationTrend]
+    creation_trends: list[ItemCreationTrend]
     # owner_distribution: List[ItemOwnerDistribution] # Optional
 
 
 router = APIRouter(prefix="/analytics", tags=["analytics"])
 tracer = trace.get_tracer(__name__)
 
+
 @router.get("/user-summary", response_model=UserAnalyticsSummary)
-def get_user_summary(session: SessionDep): # get_current_active_superuser is imported but not used here yet
+def get_user_summary(
+    session: SessionDep,
+):  # get_current_active_superuser is imported but not used here yet
     with tracer.start_as_current_span("user_summary_endpoint"):
-        
-        users_list: List[User]
+        users_list: list[User]
         with tracer.start_as_current_span("fetch_all_users_sql"):
             statement = select(User)
             users_list = session.exec(statement).all()
@@ -56,126 +63,139 @@ def get_user_summary(session: SessionDep): # get_current_active_superuser is imp
             return UserAnalyticsSummary(
                 total_users=0,
                 signup_trends=[],
-                activity_summary=UserActivity(active_users=0, inactive_users=0)
+                activity_summary=UserActivity(active_users=0, inactive_users=0),
             )
 
         with tracer.start_as_current_span("convert_users_to_polars"):
             users_data = []
             for user in users_list:
                 user_dict = {
-                    "id": user.id, # No explicit str() casting for now, per instructions
+                    "id": user.id,  # No explicit str() casting for now, per instructions
                     "email": user.email,
                     "is_active": user.is_active,
                     "is_superuser": user.is_superuser,
                     "full_name": user.full_name,
                 }
                 # Attempt to get 'created_at' if it exists (it doesn't in the standard model)
-                if hasattr(user, 'created_at') and user.created_at:
-                    user_dict['created_at'] = user.created_at
+                if hasattr(user, "created_at") and user.created_at:
+                    user_dict["created_at"] = user.created_at
                 users_data.append(user_dict)
-            
-            if not users_data: # Should not happen if users_list is not empty, but as a safe guard
-                 return UserAnalyticsSummary(
+
+            if (
+                not users_data
+            ):  # Should not happen if users_list is not empty, but as a safe guard
+                return UserAnalyticsSummary(
                     total_users=0,
                     signup_trends=[],
-                    activity_summary=UserActivity(active_users=0, inactive_users=0)
+                    activity_summary=UserActivity(active_users=0, inactive_users=0),
                 )
 
             # Create DataFrame without explicit casting of 'id' first.
             # If Polars errors on UUID, the instruction is to add:
             # df_users = df_users.with_columns(pl.col('id').cast(pl.Utf8))
             df_users = pl.DataFrame(users_data)
 
-
-        total_users = df_users.height # More idiomatic for Polars than len(df_users)
+        total_users = df_users.height  # More idiomatic for Polars than len(df_users)
 
         with tracer.start_as_current_span("calculate_user_activity_polars"):
-            active_users = df_users.filter(pl.col("is_active") == True).height
+            active_users = df_users.filter(pl.col("is_active")).height
             inactive_users = total_users - active_users
-        
+
         signup_trends_data = []
-        if 'created_at' in df_users.columns: # This will be false as User model has no created_at
+        if (
+            "created_at" in df_users.columns
+        ):  # This will be false as User model has no created_at
             with tracer.start_as_current_span("calculate_signup_trends_polars"):
                 # Ensure 'created_at' is a datetime type. If string, parse it.
                 # Assuming it's already a datetime.date or datetime.datetime from SQLModel
                 # If it's datetime, cast to date for daily trends
-                df_users_with_date = df_users.with_columns(pl.col("created_at").cast(pl.Date).alias("signup_day"))
-                
-                signup_counts_df = df_users_with_date.group_by("signup_day").agg(
-                    pl.count().alias("count")
-                ).sort("signup_day")
-                
+                df_users_with_date = df_users.with_columns(
+                    pl.col("created_at").cast(pl.Date).alias("signup_day")
+                )
+
+                signup_counts_df = (
+                    df_users_with_date.group_by("signup_day")
+                    .agg(pl.count().alias("count"))
+                    .sort("signup_day")
+                )
+
                 signup_trends_data = [
                     UserSignupTrend(signup_date=row["signup_day"], count=row["count"])
                     for row in signup_counts_df.to_dicts()
                 ]
-        
+
         return UserAnalyticsSummary(
             total_users=total_users,
-            signup_trends=signup_trends_data, # Will be empty as 'created_at' is not in User model
-            activity_summary=UserActivity(active_users=active_users, inactive_users=inactive_users)
+            signup_trends=signup_trends_data,  # Will be empty as 'created_at' is not in User model
+            activity_summary=UserActivity(
+                active_users=active_users, inactive_users=inactive_users
+            ),
         )
 
+
 @router.get("/item-trends", response_model=ItemAnalyticsTrends)
 def get_item_trends(session: SessionDep):
     with tracer.start_as_current_span("item_trends_endpoint"):
-        
-        items_list: List[Item]
+        items_list: list[Item]
         with tracer.start_as_current_span("fetch_all_items_sql"):
             statement = select(Item)
             items_list = session.exec(statement).all()
 
         if not items_list:
             return ItemAnalyticsTrends(
                 total_items=0,
-                creation_trends=[]
+                creation_trends=[],
                 # owner_distribution=[] # Optional
             )
 
         with tracer.start_as_current_span("convert_items_to_polars"):
             items_data = []
             for item in items_list:
                 item_dict = {
-                    "id": str(item.id), # Cast UUID to string
+                    "id": str(item.id),  # Cast UUID to string
                     "title": item.title,
                     "description": item.description,
-                    "owner_id": str(item.owner_id) # Cast UUID to string
+                    "owner_id": str(item.owner_id),  # Cast UUID to string
                 }
                 # IMPORTANT: Item model does not have 'created_at'.
                 # This will result in empty creation_trends.
-                if hasattr(item, 'created_at') and item.created_at:
-                    item_dict['created_at'] = item.created_at
+                if hasattr(item, "created_at") and item.created_at:
+                    item_dict["created_at"] = item.created_at
                 items_data.append(item_dict)
-            
-            if not items_data: # Safety check
+
+            if not items_data:  # Safety check
                 return ItemAnalyticsTrends(total_items=0, creation_trends=[])
 
             df_items = pl.DataFrame(items_data)
 
         total_items = df_items.height
 
         creation_trends_data = []
-        if 'created_at' in df_items.columns:
+        if "created_at" in df_items.columns:
             with tracer.start_as_current_span("calculate_item_creation_trends_polars"):
                 # Ensure 'created_at' is datetime, then cast to date for daily trends
                 df_items_with_date = df_items.with_columns(
                     pl.col("created_at").cast(pl.Date).alias("creation_day")
                 )
-                
-                creation_counts_df = df_items_with_date.group_by("creation_day").agg(
-                    pl.count().alias("count")
-                ).sort("creation_day")
-                
+
+                creation_counts_df = (
+                    df_items_with_date.group_by("creation_day")
+                    .agg(pl.count().alias("count"))
+                    .sort("creation_day")
+                )
+
                 creation_trends_data = [
-                    ItemCreationTrend(creation_date=row["creation_day"], count=row["count"])
+                    ItemCreationTrend(
+                        creation_date=row["creation_day"], count=row["count"]
+                    )
                     for row in creation_counts_df.to_dicts()
                 ]
-        
+
         # Placeholder for owner distribution if implemented later
-        # owner_distribution_data = [] 
+        # owner_distribution_data = []
 
         return ItemAnalyticsTrends(
             total_items=total_items,
-            creation_trends=creation_trends_data
+            creation_trends=creation_trends_data,
             # owner_distribution=owner_distribution_data # Optional
         )

backend/app/core/telemetry.py

@@ -1,44 +1,43 @@
 import os
+
 from opentelemetry import trace
 from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
+from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
 from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import BatchSpanProcessor
-from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
-from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
 
-from app.core.db import engine # Assuming engine is in app.core.db
-from app.core.config import settings # To potentially get service name
+from app.core.config import settings  # To potentially get service name
+from app.core.db import engine  # Assuming engine is in app.core.db
+
 
 def init_telemetry(app):
     # Set service name, try from settings or default
     service_name = getattr(settings, "OTEL_SERVICE_NAME", "fastapi-application")
-    
-    resource = Resource(attributes={
-        "service.name": service_name
-    })
-
-    # Configure OTLP exporter
-    # Endpoint can be configured via OTEL_EXPORTER_OTLP_ENDPOINT environment variable
-    # Defaulting to http://localhost:4317 if not set, as per OpenTelemetry spec
-    otlp_endpoint = os.getenv("OTEL_EXPORTER_OTLP_ENDPOINT", "http://localhost:4317")
-    
-    span_exporter = OTLPSpanExporter(
-        endpoint=otlp_endpoint,
-        # insecure=True # Set to True if your collector is not using TLS. Adjust as needed.
-    )
-    
-    processor = BatchSpanProcessor(span_exporter)
-    
+
+    resource = Resource(attributes={"service.name": service_name})
+
+    # Configure OTLP exporter only if endpoint is explicitly set
+    # This prevents connection attempts in CI/test environments
+    otlp_endpoint = os.getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
+
     provider = TracerProvider(resource=resource)
-    provider.add_span_processor(processor)
-    
+
+    if otlp_endpoint:
+        span_exporter = OTLPSpanExporter(
+            endpoint=otlp_endpoint,
+            # insecure=True # Set to True if your collector is not using TLS. Adjust as needed.
+        )
+        processor = BatchSpanProcessor(span_exporter)
+        provider.add_span_processor(processor)
+
     # Sets the global default tracer provider
     trace.set_tracer_provider(provider)
-    
+
     # Instrument FastAPI
     FastAPIInstrumentor.instrument_app(app)
-    
+
     # Instrument SQLAlchemy
     # Ensure the engine is already configured/available when this is called.
     SQLAlchemyInstrumentor().instrument(engine=engine)

backend/app/tests/api/test_analytics.py

@@ -1,14 +1,14 @@
 from fastapi.testclient import TestClient
-from sqlmodel import Session # For potential future use with fixtures
-import pytest # For potential future use with fixtures
 
 from app.core.config import settings
+
 # Assuming your FastAPI app instance is named 'app' in 'app.main'
 # Adjust the import if your app instance is located elsewhere for tests
-# from app.main import app 
+# from app.main import app
 
 # Expected Pydantic response models (adjust import path if they are moved)
-# from app.api.routes.analytics import UserAnalyticsSummary, ItemAnalyticsTrends 
+# from app.api.routes.analytics import UserAnalyticsSummary, ItemAnalyticsTrends
+
 
 # Test for User Analytics Summary
 def test_get_user_summary(client: TestClient) -> None: