🚀 Auto-deploy from GitHub

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "python.analysis.extraPaths": [
+        "./app"
+    ]
+}

app/api/v1/endpoints/generate.py

@@ -1,4 +1,4 @@
-from fastapi import APIRouter, HTTPException, Depends
+from fastapi import APIRouter, HTTPException, Depends, Request
 from dotenv import load_dotenv
 from supabase import Client
 import uuid
@@ -12,6 +12,8 @@ from ....core.config import settings
 from ....core.model_loader import get_generator
 from ....core.constraints import generate_with_retry, check_constraints
 from ....core.auth import authenticate_request, get_current_user
+from ....services.request_logger import RequestEventLogger
+from ....services.auth_logger import get_client_info
 from fastapi.concurrency import run_in_threadpool # Importieren
 
 load_dotenv()
@@ -28,11 +30,18 @@ async def generate_qr_code_async(*args, **kwargs):
 @router.post("/generate", response_model=CardGenerateResponse)
 async def generate_endpoint(
     request: CardGenerateRequest, 
+    fastapi_request: Request,
     supabase: Client = Depends(get_supabase_client),
     authenticated: bool = Depends(authenticate_request),
     current_user: Optional[Dict[str, Any]] = Depends(get_current_user)
 ):
     try:
+        # Generate unique request ID for tracking
+        request_id = str(uuid.uuid4())
+        
+        # Extract client information
+        client_ip, user_agent = get_client_info(fastapi_request)
+        
         lang = request.lang or "de"
         input_date_str = request.card_date.isoformat()
         
@@ -40,10 +49,25 @@ async def generate_endpoint(
         user_id = current_user["id"] if current_user else None
         username = current_user["username"] if current_user else "anonymous"
         
+        # Log incoming request
+        RequestEventLogger.log_card_generation_request(
+            user_id=user_id,
+            username=username,
+            client_ip=client_ip,
+            user_agent=user_agent,
+            terms=request.terms,
+            card_date=input_date_str,
+            lang=lang,
+            card_design_id=request.card_design_id_override,
+            symbol_ids=request.symbol_ids_override,
+            request_id=request_id
+        )
+        
         card_prompt = build_prompt(
             lang=lang,
             card_date=input_date_str,
-            terms=request.terms
+            terms=request.terms,
+            request_id=request_id
         )
 
         llm_pipeline = get_generator()
@@ -62,13 +86,23 @@ async def generate_endpoint(
             generator=llm_pipeline,
             terms=request.terms,
             max_retries=settings.GENERATION_MAX_RETRIES,
-            generation_params=generation_params
+            generation_params=generation_params,
+            request_id=request_id
         )
 
         if card_text == "Leider konnte kein gültiger Text erzeugt werden." or not check_constraints(card_text, request.terms):
+            error_msg = "Kartentext konnte nicht generiert werden oder erfüllt nicht die Bedingungen."
+            
+            # Log failed card generation
+            RequestEventLogger.log_card_generation_result(
+                request_id=request_id,
+                success=False,
+                error_message=error_msg
+            )
+            
             raise HTTPException(
                 status_code=500, 
-                detail="Kartentext konnte nicht generiert werden oder erfüllt nicht die Bedingungen."
+                detail=error_msg
             )
 
         card_id_for_url = str(uuid.uuid4())
@@ -91,7 +125,8 @@ async def generate_endpoint(
             base_images_path=settings.resolved_base_path,
             symbols_images_path=settings.resolved_symbols_path,
             font_path=settings.resolved_default_font_path,
-            output_path=settings.resolved_generated_path
+            output_path=settings.resolved_generated_path,
+            request_id=request_id
         )
 
         card_data_for_db = {
@@ -115,18 +150,52 @@ async def generate_endpoint(
         elif isinstance(db_response, list) and db_response and isinstance(db_response[0], dict): 
              db_id = str(db_response[0].get('id'))
 
+        # Log successful card generation
+        RequestEventLogger.log_card_generation_result(
+            request_id=request_id,
+            success=True,
+            card_id=db_id if db_id else card_id_for_url,
+            card_file_id=card_file_id,
+            qr_code_file_id=qr_code_file_id,
+            qr_content_url=qr_content_url
+        )
+
         return CardGenerateResponse(
             message="Karte erfolgreich generiert.",
             card_id=db_id if db_id else card_id_for_url, 
             qr_code_image_url=qr_code_url
         )
     except FileNotFoundError as e:
+        error_msg = f"Ein benötigtes Template oder eine Datei wurde nicht gefunden: {e.filename}"
         print(f"FileNotFoundError in generate_endpoint: {e}")
-        raise HTTPException(status_code=500, detail=f"Ein benötigtes Template oder eine Datei wurde nicht gefunden: {e.filename}")
+        
+        # Log failed card generation
+        RequestEventLogger.log_card_generation_result(
+            request_id=request_id,
+            success=False,
+            error_message=error_msg
+        )
+        
+        raise HTTPException(status_code=500, detail=error_msg)
     except HTTPException as e:
+        # Log failed card generation for HTTP exceptions
+        RequestEventLogger.log_card_generation_result(
+            request_id=request_id if 'request_id' in locals() else None,
+            success=False,
+            error_message=str(e.detail)
+        )
         raise e
     except Exception as e:
+        error_msg = f"Ein interner Fehler ist aufgetreten: {str(e)}"
         import traceback
         print(f"Unerwarteter Fehler in generate_endpoint: {type(e).__name__} - {str(e)}")
         traceback.print_exc()
-        raise HTTPException(status_code=500, detail=f"Ein interner Fehler ist aufgetreten: {str(e)}")
+        
+        # Log failed card generation
+        RequestEventLogger.log_card_generation_result(
+            request_id=request_id if 'request_id' in locals() else None,
+            success=False,
+            error_message=error_msg
+        )
+        
+        raise HTTPException(status_code=500, detail=error_msg)

app/core/card_renderer.py

@@ -2,6 +2,20 @@ from PIL import Image, ImageDraw, ImageFont
 import uuid
 from pathlib import Path
 
+# Handle import for both package and direct execution
+try:
+    from ..services.request_logger import RequestEventLogger
+except ImportError:
+    # If relative import fails, try absolute import or create a dummy logger
+    try:
+        from app.services.request_logger import RequestEventLogger
+    except ImportError:
+        # Create a dummy logger class if import fails
+        class RequestEventLogger:
+            @staticmethod
+            def log_card_renderer_params(*args, **kwargs):
+                pass
+
 def generate_card(
     card_design_id: int, 
     symbol_ids: list[int], 
@@ -9,13 +23,28 @@ def generate_card(
     base_images_path: Path,
     symbols_images_path: Path,
     font_path: Path,
-    output_path: Path
+    output_path: Path,
+    request_id: str | None = None
 ) -> str:
     """
     Generiert eine Karte und speichert sie.
     Verwendet jetzt übergebene Pfade für mehr Flexibilität und Testbarkeit.
     Gibt die UUID der generierten Datei (ohne Erweiterung) zurück.
     """
+    
+    # Log card renderer parameters
+    if request_id:
+        RequestEventLogger.log_card_renderer_params(
+            request_id=request_id,
+            card_design_id=card_design_id,
+            symbol_ids=symbol_ids,
+            text=text,
+            base_images_path=str(base_images_path),
+            symbols_images_path=str(symbols_images_path),
+            font_path=str(font_path),
+            output_path=str(output_path)
+        )
+    
     try:
         # Basiskarte laden
         base_image_file = base_images_path / f"base{card_design_id}.png"

app/core/config.py

@@ -40,7 +40,8 @@ class Settings(BaseSettings):
     GENERATION_TOP_P: float = 0.95
     GENERATION_MAX_RETRIES: int = 3
 
-    FRONTEND_BASE_URL: str = "http://localhost:3000"
+    # Frontend URL for QR codes - should be set to production URL in production
+    FRONTEND_BASE_URL: str = os.getenv("FRONTEND_BASE_URL", "https://huggingface.co/spaces/ch404/cardserver")
     QR_CODE_SIZE: int = 200
     QR_CODE_BOX_SIZE: int = 10 
     QR_CODE_BORDER: int = 4 

app/core/constraints.py

@@ -3,32 +3,93 @@
 import asyncio 
 from fastapi.concurrency import run_in_threadpool
 
+# Handle import for both package and direct execution
+try:
+    from ..services.request_logger import RequestEventLogger
+except ImportError:
+    # If relative import fails, try absolute import or create a dummy logger
+    try:
+        from app.services.request_logger import RequestEventLogger
+    except ImportError:
+        # Create a dummy logger class if import fails
+        class RequestEventLogger:
+            @staticmethod
+            def log_llm_request(*args, **kwargs):
+                pass
+            @staticmethod
+            def log_llm_response(*args, **kwargs):
+                pass
+
 def check_constraints(output: str, terms: list[str]) -> bool:
     if not terms:
         return True
     return all(term.lower() in output.lower() for term in terms)
 
-async def generate_with_retry(prompt: str, generator, terms: list[str], max_retries: int = 3, generation_params: dict | None = None): # async def
+async def generate_with_retry(prompt: str, generator, terms: list[str], max_retries: int = 3, generation_params: dict | None = None, request_id: str | None = None): # async def
     """
     Generiert Text mit Wiederholungsversuchen, bis die Bedingungen (Constraints) erfüllt sind.
     Führt die eigentliche Generierung in einem Threadpool aus.
     """
     if generation_params is None:
         generation_params = {}
+    
+    # Log LLM request
+    model_info = {"generator_type": str(type(generator).__name__)}
+    if hasattr(generator, 'model'):
+        if hasattr(generator.model, 'config'):
+            model_info.update(generator.model.config.to_dict() if hasattr(generator.model.config, 'to_dict') else {"config": str(generator.model.config)})
+        model_info["model_name"] = str(type(generator.model).__name__)
+    
+    RequestEventLogger.log_llm_request(
+        request_id=request_id,
+        prompt=prompt,
+        generation_params=generation_params,
+        model_info=model_info
+    )
         
     for attempt in range(max_retries):
         try:
             responses = await run_in_threadpool(generator, prompt, **generation_params)
             if responses and isinstance(responses, list) and responses[0].get("generated_text"):
                 generated_text = responses[0]["generated_text"].strip()
-                if check_constraints(generated_text, terms):
+                constraints_met = check_constraints(generated_text, terms)
+                
+                # Log LLM response
+                RequestEventLogger.log_llm_response(
+                    request_id=request_id,
+                    generated_text=generated_text,
+                    attempt=attempt + 1,
+                    constraints_met=constraints_met,
+                    terms=terms
+                )
+                
+                if constraints_met:
                     return generated_text
             else:
                 print(f"Unerwartete Antwortstruktur vom Generator bei Versuch {attempt + 1}: {responses}")
-                generated_text = "" 
+                generated_text = ""
+                
+                # Log failed response
+                RequestEventLogger.log_llm_response(
+                    request_id=request_id,
+                    generated_text="",
+                    attempt=attempt + 1,
+                    constraints_met=False,
+                    terms=terms
+                )
 
         except Exception as e:
             print(f"Fehler bei der Textgenerierung (Versuch {attempt + 1}/{max_retries}): {e}")
+            
+            # Log error response
+            RequestEventLogger.log_llm_response(
+                request_id=request_id,
+                generated_text=f"ERROR: {str(e)}",
+                attempt=attempt + 1,
+                constraints_met=False,
+                terms=terms
+            )
+            
             await asyncio.sleep(0.5)
             
     return "Leider konnte kein gültiger Text erzeugt werden."

app/core/generator.py

@@ -2,6 +2,20 @@ from jinja2 import Template
 from pathlib import Path
 import datetime
 
+# Handle import for both package and direct execution
+try:
+    from ..services.request_logger import RequestEventLogger
+except ImportError:
+    # If relative import fails, try absolute import or create a dummy logger
+    try:
+        from app.services.request_logger import RequestEventLogger
+    except ImportError:
+        # Create a dummy logger class if import fails
+        class RequestEventLogger:
+            @staticmethod
+            def log_generator_prompt(*args, **kwargs):
+                pass
+
 """ MMDD → MM = Monat, DD = Tag
 120 = 01.20. → Ende Steinbock
 218 = 02.18. → Ende Wassermann
@@ -33,13 +47,27 @@ Der Text soll die Schlüsselbegriffe kreativ und subtil einbinden und zum angege
 Antworte nur mit dem Horoskoptext.
 """)
 
-def build_prompt(lang: str, card_date: str, terms: list[str]) -> str:
+def build_prompt(lang: str, card_date: str, terms: list[str], request_id: str | None = None) -> str:
     """Baut den Prompt für das LLM basierend auf Geburtsdatum und Begriffen."""
     constellation = get_constellation(card_date)
     terms_str = ", ".join(terms)
-    return PROMPT_TEMPLATE.render(
+    
+    prompt = PROMPT_TEMPLATE.render(
         lang=lang, 
         card_date=card_date, 
         constellation=constellation, 
         terms_str=terms_str
-    )
+    )
+    
+    # Log the generator prompt
+    if request_id:
+        RequestEventLogger.log_generator_prompt(
+            request_id=request_id,
+            prompt=prompt,
+            terms=terms,
+            card_date=card_date,
+            constellation=constellation,
+            lang=lang
+        )
+    
+    return prompt

app/services/request_logger.py

@@ -0,0 +1,195 @@
+"""
+Request logging service for card generation requests
+"""
+
+import logging
+import json
+from datetime import datetime
+from typing import Optional, Dict, Any, List
+from pathlib import Path
+
+# Create logs directory if it doesn't exist
+logs_dir = Path("logs")
+logs_dir.mkdir(exist_ok=True)
+
+# Create a specific logger for request events
+request_logger = logging.getLogger("request_events")
+request_logger.setLevel(logging.INFO)
+
+# Create file handler for request logs
+request_log_file = logs_dir / "request_events.log"
+file_handler = logging.FileHandler(request_log_file)
+file_handler.setLevel(logging.INFO)
+
+# Create console handler for important events
+console_handler = logging.StreamHandler()
+console_handler.setLevel(logging.INFO)
+
+# Create formatter for structured logging
+formatter = logging.Formatter(
+    '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S'
+)
+
+file_handler.setFormatter(formatter)
+console_handler.setFormatter(formatter)
+
+# Add handlers to logger
+request_logger.addHandler(file_handler)
+request_logger.addHandler(console_handler)
+
+# Prevent propagation to root logger to avoid duplicate logs
+request_logger.propagate = False
+
+
+class RequestEventLogger:
+    """Request event logging with structured file output"""
+    
+    @staticmethod
+    def log_card_generation_request(
+        user_id: Optional[str],
+        username: str,
+        client_ip: str,
+        user_agent: str,
+        terms: List[str],
+        card_date: str,
+        lang: str,
+        card_design_id: Optional[int] = None,
+        symbol_ids: Optional[List[int]] = None,
+        request_id: Optional[str] = None
+    ):
+        """Log incoming card generation request"""
+        event_data = {
+            "event": "card_generation_request",
+            "request_id": request_id,
+            "user_id": user_id,
+            "username": username,
+            "client_ip": client_ip,
+            "user_agent": user_agent,
+            "terms": terms,
+            "card_date": card_date,
+            "lang": lang,
+            "card_design_id": card_design_id,
+            "symbol_ids": symbol_ids,
+            "timestamp": datetime.utcnow().isoformat()
+        }
+        
+        request_logger.info(f"CARD_REQUEST: {json.dumps(event_data)}")
+    
+    @staticmethod
+    def log_generator_prompt(
+        request_id: Optional[str],
+        prompt: str,
+        terms: List[str],
+        card_date: str,
+        constellation: str,
+        lang: str
+    ):
+        """Log the prompt sent to the generator"""
+        event_data = {
+            "event": "generator_prompt",
+            "request_id": request_id,
+            "prompt": prompt,
+            "terms": terms,
+            "card_date": card_date,
+            "constellation": constellation,
+            "lang": lang,
+            "timestamp": datetime.utcnow().isoformat()
+        }
+        
+        request_logger.info(f"GENERATOR_PROMPT: {json.dumps(event_data)}")
+    
+    @staticmethod
+    def log_llm_request(
+        request_id: Optional[str],
+        prompt: str,
+        generation_params: Dict[str, Any],
+        model_info: Dict[str, Any]
+    ):
+        """Log the request sent to the LLM via HF API"""
+        event_data = {
+            "event": "llm_request",
+            "request_id": request_id,
+            "prompt": prompt,
+            "generation_params": generation_params,
+            "model_info": model_info,
+            "timestamp": datetime.utcnow().isoformat()
+        }
+        
+        request_logger.info(f"LLM_REQUEST: {json.dumps(event_data)}")
+    
+    @staticmethod
+    def log_llm_response(
+        request_id: Optional[str],
+        generated_text: str,
+        attempt: int,
+        constraints_met: bool,
+        terms: List[str]
+    ):
+        """Log the response from the LLM"""
+        event_data = {
+            "event": "llm_response",
+            "request_id": request_id,
+            "generated_text": generated_text,
+            "attempt": attempt,
+            "constraints_met": constraints_met,
+            "terms": terms,
+            "timestamp": datetime.utcnow().isoformat()
+        }
+        
+        request_logger.info(f"LLM_RESPONSE: {json.dumps(event_data)}")
+    
+    @staticmethod
+    def log_card_renderer_params(
+        request_id: Optional[str],
+        card_design_id: int,
+        symbol_ids: List[int],
+        text: str,
+        base_images_path: str,
+        symbols_images_path: str,
+        font_path: str,
+        output_path: str
+    ):
+        """Log parameters sent to card renderer"""
+        event_data = {
+            "event": "card_renderer_params",
+            "request_id": request_id,
+            "card_design_id": card_design_id,
+            "symbol_ids": symbol_ids,
+            "text": text,
+            "base_images_path": str(base_images_path),
+            "symbols_images_path": str(symbols_images_path),
+            "font_path": str(font_path),
+            "output_path": str(output_path),
+            "timestamp": datetime.utcnow().isoformat()
+        }
+        
+        request_logger.info(f"CARD_RENDERER_PARAMS: {json.dumps(event_data)}")
+    
+    @staticmethod
+    def log_card_generation_result(
+        request_id: Optional[str],
+        success: bool,
+        card_id: Optional[str] = None,
+        card_file_id: Optional[str] = None,
+        qr_code_file_id: Optional[str] = None,
+        qr_content_url: Optional[str] = None,
+        error_message: Optional[str] = None
+    ):
+        """Log the final result of card generation"""
+        event_data = {
+            "event": "card_generation_result",
+            "request_id": request_id,
+            "success": success,
+            "card_id": card_id,
+            "card_file_id": card_file_id,
+            "qr_code_file_id": qr_code_file_id,
+            "qr_content_url": qr_content_url,
+            "error_message": error_message,
+            "timestamp": datetime.utcnow().isoformat()
+        }
+        
+        if success:
+            request_logger.info(f"CARD_GENERATION_SUCCESS: {json.dumps(event_data)}")
+        else:
+            request_logger.error(f"CARD_GENERATION_FAILED: {json.dumps(event_data)}")

app/utils/qr_utils.py

@@ -1,7 +1,20 @@
 import qrcode
 from pathlib import Path
 import uuid
-from ..core.config import settings
+
+# Handle import for both package and direct execution
+try:
+    from ..core.config import settings
+except ImportError:
+    # If relative import fails, try absolute import
+    try:
+        from app.core.config import settings
+    except ImportError:
+        # Create a minimal settings object if import fails
+        class MinimalSettings:
+            QR_CODE_BOX_SIZE = 10
+            QR_CODE_BORDER = 4
+        settings = MinimalSettings()
 
 def generate_qr_code_sync(data: str, output_path: Path, size: int) -> str:
     """

test_card_renderer.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+
+import sys
+import traceback
+from pathlib import Path
+
+# Add the app directory to Python path
+sys.path.insert(0, str(Path(__file__).parent / "app"))
+
+try:
+    from core.card_renderer import generate_card
+    from core.config import settings
+    
+    print('Testing card renderer...')
+    
+    # Test parameters
+    card_design_id = 1
+    symbol_ids = [1, 2]
+    text = 'Test card text for debugging'
+    
+    file_id = generate_card(
+        card_design_id=card_design_id,
+        symbol_ids=symbol_ids,
+        text=text,
+        base_images_path=settings.resolved_base_path,
+        symbols_images_path=settings.resolved_symbols_path,
+        font_path=settings.resolved_default_font_path,
+        output_path=settings.resolved_generated_path,
+        request_id='test-12345'
+    )
+    
+    print(f'Success! Generated card with ID: {file_id}')
+    
+    # Check if file was created
+    output_file = settings.resolved_generated_path / f'{file_id}.png'
+    print(f'File exists: {output_file.exists()}')
+    if output_file.exists():
+        print(f'File size: {output_file.stat().st_size} bytes')
+    
+except Exception as e:
+    print(f'Error: {type(e).__name__}: {str(e)}')
+    traceback.print_exc()

tests/test_card_renderer.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+
+import sys
+import traceback
+from pathlib import Path
+
+# Add the app directory to Python path
+sys.path.insert(0, str(Path(__file__).parent / "app"))
+
+try:
+    from core.card_renderer import generate_card
+    from core.config import settings
+    
+    print('Testing card renderer...')
+    
+    # Test parameters
+    card_design_id = 1
+    symbol_ids = [1, 2]
+    text = 'Test card text for debugging'
+    
+    file_id = generate_card(
+        card_design_id=card_design_id,
+        symbol_ids=symbol_ids,
+        text=text,
+        base_images_path=settings.resolved_base_path,
+        symbols_images_path=settings.resolved_symbols_path,
+        font_path=settings.resolved_default_font_path,
+        output_path=settings.resolved_generated_path,
+        request_id='test-12345'
+    )
+    
+    print(f'Success! Generated card with ID: {file_id}')
+    
+    # Check if file was created
+    output_file = settings.resolved_generated_path / f'{file_id}.png'
+    print(f'File exists: {output_file.exists()}')
+    if output_file.exists():
+        print(f'File size: {output_file.stat().st_size} bytes')
+    
+except Exception as e:
+    print(f'Error: {type(e).__name__}: {str(e)}')
+    traceback.print_exc()

tests/test_logging.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""
+Test script to verify logging functionality
+"""
+
+import sys
+import os
+
+# Add the app directory to the Python path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'app'))
+
+from services.request_logger import RequestEventLogger
+from datetime import datetime
+
+def test_logging():
+    """Test the request logging functionality"""
+    
+    print("Testing request logging...")
+    
+    # Test initial request logging
+    RequestEventLogger.log_card_generation_request(
+        user_id="test-user-123",
+        username="test_user",
+        client_ip="127.0.0.1",
+        user_agent="Mozilla/5.0 (test)",
+        terms=["Liebe", "Abenteuer", "Erfolg"],
+        card_date="2025-06-17",
+        lang="de",
+        card_design_id=1,
+        symbol_ids=[1, 2, 3],
+        request_id="test-request-123"
+    )
+    
+    # Test generator prompt logging
+    RequestEventLogger.log_generator_prompt(
+        request_id="test-request-123",
+        prompt="Du bist ein Sexoskop-Orakel...",
+        terms=["Liebe", "Abenteuer", "Erfolg"],
+        card_date="2025-06-17",
+        constellation="Zwillinge",
+        lang="de"
+    )
+    
+    # Test LLM request logging
+    RequestEventLogger.log_llm_request(
+        request_id="test-request-123",
+        prompt="Du bist ein Sexoskop-Orakel...",
+        generation_params={
+            "max_new_tokens": 100,
+            "temperature": 0.7,
+            "do_sample": True
+        },
+        model_info={"model_name": "test-model", "version": "1.0"}
+    )
+    
+    # Test LLM response logging
+    RequestEventLogger.log_llm_response(
+        request_id="test-request-123",
+        generated_text="Die Sterne stehen günstig für Liebe und Abenteuer.",
+        attempt=1,
+        constraints_met=True,
+        terms=["Liebe", "Abenteuer", "Erfolg"]
+    )
+    
+    # Test card renderer params logging
+    RequestEventLogger.log_card_renderer_params(
+        request_id="test-request-123",
+        card_design_id=1,
+        symbol_ids=[1, 2, 3],
+        text="Die Sterne stehen günstig für Liebe und Abenteuer.",
+        base_images_path="/path/to/base/images",
+        symbols_images_path="/path/to/symbols",
+        font_path="/path/to/font",
+        output_path="/path/to/output"
+    )
+    
+    # Test successful result logging
+    RequestEventLogger.log_card_generation_result(
+        request_id="test-request-123",
+        success=True,
+        card_id="card-123",
+        card_file_id="file-123",
+        qr_code_file_id="qr-123",
+        qr_content_url="https://example.com/card/123"
+    )
+    
+    print("✅ Logging test completed successfully!")
+    print("📁 Check logs/request_events.log for the logged events")
+
+if __name__ == "__main__":
+    test_logging()