Update app.py

app.py

@@ -14,6 +14,8 @@ import uuid
 from user_agents import parse as parse_ua
 import schedule
 import threading
+import io
+import atexit
 
 # --- Konfiguration ---
 CHARGENODE_URL = "https://www.chargenode.eu"
@@ -55,14 +57,42 @@ scheduler = CommitScheduler(
 
 # --- Globala variabler ---
 last_log = None  # Sparar loggdata från senaste svar för feedback
+# Lägg till en lock för att skydda åtkomst till last_log
+last_log_lock = threading.Lock()
 
 # --- Förbättrad loggfunktion ---
 def safe_append_to_log(log_entry):
     """Säker metod för att lägga till loggdata utan att förlora historisk information."""
     try:
+        # Kontrollera att loggmappen finns
+        os.makedirs(os.path.dirname(log_file_path), exist_ok=True)
+        
+        # Kontrollera loggfilens storlek
+        try:
+            log_size = os.path.getsize(log_file_path)
+            # Om loggfilen är större än 10MB, rotera den
+            if log_size > 10 * 1024 * 1024:  # 10MB
+                backup_path = f"{log_file_path}.bak"
+                if os.path.exists(backup_path):
+                    os.remove(backup_path)
+                os.rename(log_file_path, backup_path)
+                print(f"Loggfil roterad: {log_file_path} -> {backup_path}")
+        except FileNotFoundError:
+            # Filen finns inte än, inget att rotera
+            pass
+            
+        # Sanitera loggdata för att undvika potentiella injektioner
+        sanitized_entry = {}
+        for k, v in log_entry.items():
+            if isinstance(v, str):
+                # Ta bort null-bytes och begränsa längden
+                sanitized_entry[k] = v.replace('\0', '')[:10000]  # Begränsa till 10000 tecken
+            else:
+                sanitized_entry[k] = v
+        
         # Öppna filen i append-läge
         with open(log_file_path, "a", encoding="utf-8") as log_file:
-            log_json = json.dumps(log_entry)
+            log_json = json.dumps(sanitized_entry)
             log_file.write(log_json + "\n")
             log_file.flush()  # Säkerställ att data skrivs till disk omedelbart
             
@@ -72,16 +102,22 @@ def safe_append_to_log(log_entry):
     except Exception as e:
         print(f"Fel vid loggning: {e}")
         
-        # Försök skapa mappen om den inte finns
+        # Försök skapa mappen om den inte finns (detta bör redan ha gjorts ovan)
         try:
             os.makedirs(os.path.dirname(log_file_path), exist_ok=True)
             
-            # Försök igen
+            # Försök igen med minimal loggdata för att undvika fel
+            minimal_entry = {
+                "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                "error": f"Fel vid loggning: {str(e)[:200]}",
+                "recovery": True
+            }
+            
             with open(log_file_path, "a", encoding="utf-8") as log_file:
-                log_json = json.dumps(log_entry)
+                log_json = json.dumps(minimal_entry)
                 log_file.write(log_json + "\n")
                 
-            print("Loggpost tillagd efter återhämtning")
+            print("Minimal loggpost tillagd efter återhämtning")
             return True
             
         except Exception as retry_error:
@@ -156,41 +192,111 @@ def prepare_chunks(text_data):
 embedder = None
 embeddings = None
 index = None
+chunks = []
+chunk_sources = []
+embedding_lock = threading.Lock()
 
 def initialize_embeddings():
     """Initierar SentenceTransformer och FAISS-index vid första anrop."""
     global embedder, embeddings, index, chunks, chunk_sources
     
-    if embedder is None:
-        print("Initierar SentenceTransformer och FAISS-index...")
-        # Ladda och förbered lokal data
-        print("Laddar textdata...")
-        text_data = {"local_files": load_local_files()}
-        print("Förbereder textsegment...")
-        chunks, chunk_sources = prepare_chunks(text_data)
-        print(f"{len(chunks)} segment laddade")
-
-        print("Skapar embeddings...")
-        embedder = SentenceTransformer('all-MiniLM-L6-v2')
-        embeddings = embedder.encode(chunks, convert_to_numpy=True)
-        embeddings /= np.linalg.norm(embeddings, axis=1, keepdims=True)
-        index = faiss.IndexFlatIP(embeddings.shape[1])
-        index.add(embeddings)
-        print("FAISS-index klart")
+    # Använd en lock för att förhindra att flera trådar initierar samtidigt
+    with embedding_lock:
+        if embedder is None:
+            try:
+                print("Initierar SentenceTransformer och FAISS-index...")
+                # Ladda och förbered lokal data
+                print("Laddar textdata...")
+                text_data = {"local_files": load_local_files()}
+                print("Förbereder textsegment...")
+                chunks, chunk_sources = prepare_chunks(text_data)
+                print(f"{len(chunks)} segment laddade")
+
+                if not chunks:
+                    print("Varning: Inga textsegment hittades. Kontrollera textdata.")
+                    # Skapa tomma listor för att undvika fel
+                    chunks = [""]
+                    chunk_sources = ["empty"]
+
+                print("Skapar embeddings...")
+                embedder = SentenceTransformer('all-MiniLM-L6-v2')
+                embeddings = embedder.encode(chunks, convert_to_numpy=True)
+                
+                # Kontrollera att embeddings inte är tomma
+                if embeddings.size > 0:
+                    embeddings /= np.linalg.norm(embeddings, axis=1, keepdims=True)
+                    index = faiss.IndexFlatIP(embeddings.shape[1])
+                    index.add(embeddings)
+                    print("FAISS-index klart")
+                else:
+                    print("Varning: Tomma embeddings. Skapar ett tomt index.")
+                    # Skapa ett tomt index med rätt dimensioner
+                    index = faiss.IndexFlatIP(384)  # Standard dimension för all-MiniLM-L6-v2
+            except Exception as e:
+                print(f"Fel vid initiering av embeddings: {e}")
+                # Sätt upp grundläggande värden för att undvika fel
+                if embedder is None:
+                    print("Försöker återhämta från fel...")
+                    try:
+                        embedder = SentenceTransformer('all-MiniLM-L6-v2')
+                        if not chunks:
+                            chunks = ["Fel vid laddning av data"]
+                            chunk_sources = ["error"]
+                        embeddings = embedder.encode(chunks, convert_to_numpy=True)
+                        index = faiss.IndexFlatIP(embeddings.shape[1])
+                        index.add(embeddings)
+                        print("Återhämtning lyckades")
+                    except Exception as recovery_error:
+                        print(f"Kunde inte återhämta: {recovery_error}")
+                        # Sätt upp dummy-värden som sista utväg
+                        embedder = None
+                        embeddings = np.zeros((1, 384))
+                        index = faiss.IndexFlatIP(384)
 def retrieve_context(query, k=RETRIEVAL_K):
     """Hämtar relevant kontext för frågor."""
     # Säkerställ att modeller är laddade
     initialize_embeddings()
     
-    query_embedding = embedder.encode([query], convert_to_numpy=True)
-    query_embedding /= np.linalg.norm(query_embedding)
-    D, I = index.search(query_embedding, k)
-    retrieved, sources = [], set()
-    for idx in I[0]:
-        if idx < len(chunks):
-            retrieved.append(chunks[idx])
-            sources.add(chunk_sources[idx])
-    return " ".join(retrieved), list(sources)
+    try:
+        if embedder is None:
+            print("Varning: Embedder är fortfarande None efter initiering")
+            return "Kunde inte ladda kontext", ["error"]
+            
+        query_embedding = embedder.encode([query], convert_to_numpy=True)
+        
+        # Kontrollera att embedding inte är tom
+        if query_embedding.size == 0:
+            print("Varning: Tom query embedding")
+            return "Kunde inte bearbeta frågan", ["error"]
+            
+        query_embedding /= np.linalg.norm(query_embedding)
+        
+        # Kontrollera att index finns
+        if index is None:
+            print("Varning: FAISS-index är None")
+            return "Kunde inte söka i kontext", ["error"]
+            
+        # Säkerställ att k inte är större än antalet element i index
+        actual_k = min(k, index.ntotal)
+        if actual_k < k:
+            print(f"Varning: Justerade k från {k} till {actual_k} baserat på index.ntotal")
+            
+        D, I = index.search(query_embedding, actual_k)
+        
+        retrieved, sources = [], set()
+        for idx in I[0]:
+            if 0 <= idx < len(chunks):
+                retrieved.append(chunks[idx])
+                sources.add(chunk_sources[idx])
+        
+        if not retrieved:
+            print("Varning: Ingen relevant kontext hittades")
+            return "Ingen relevant kontext hittades", ["no_context"]
+            
+        return " ".join(retrieved), list(sources)
+    except Exception as e:
+        print(f"Fel vid hämtning av kontext: {e}")
+        return f"Fel vid kontexthämtning: {str(e)[:200]}", ["error"]
 
 def generate_answer(query):
     """Genererar svar baserat på fråga och kontextinformation."""
@@ -271,18 +377,27 @@ def vote(data: gr.LikeData):
     data.value innehåller information om meddelandet.
     """
     feedback_type = "up" if data.liked else "down"
-    global last_log
+    global last_log, last_log_lock
+    
+    # Skapa en kopia av data.value för att undvika potentiella race conditions
+    bot_reply = data.value if not isinstance(data.value, dict) else data.value.get("value", "")
+    if bot_reply is None:
+        bot_reply = ""
+    
     log_entry = {
         "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
         "feedback": feedback_type,
-        "bot_reply": data.value if not isinstance(data.value, dict) else data.value.get("value")
+        "bot_reply": bot_reply
     }
-    # Om global logdata finns, lägg till ytterligare metadata.
-    if last_log:
-        log_entry.update({
-            "session_id": last_log.get("session_id"),
-            "user_message": last_log.get("user_message"),
-        })
+    
+    # Använd lock för att säkert komma åt last_log
+    with last_log_lock:
+        # Om global logdata finns, lägg till ytterligare metadata.
+        if last_log:
+            log_entry.update({
+                "session_id": last_log.get("session_id", "unknown"),
+                "user_message": last_log.get("user_message", "Okänd fråga"),
+            })
     
     # Använd den förbättrade loggfunktionen
     safe_append_to_log(log_entry)
@@ -290,10 +405,16 @@ def vote(data: gr.LikeData):
     # Skicka feedback till Slack
     try:
         if feedback_type == "down":  # Skicka bara negativ feedback
+            # Hämta user_message säkert
+            user_message = "Okänd fråga"
+            with last_log_lock:
+                if last_log:
+                    user_message = last_log.get("user_message", "Okänd fråga")
+            
             feedback_message = f"""
 *⚠️ Negativ feedback registrerad*
 
-*Fråga:* {last_log.get('user_message', 'Okänd fråga')}
+*Fråga:* {user_message}
 
 *Svar:* {log_entry.get('bot_reply', 'Okänt svar')[:300]}{'...' if len(log_entry.get('bot_reply', '')) > 300 else ''}
 """
@@ -536,26 +657,69 @@ def send_support_to_slack(områdeskod, uttagsnummer, email, chat_history):
 # --- Schemaläggning av rapporter ---
 def run_scheduler():
     """Kör schemaläggaren i en separat tråd med förenklad statusrapportering."""
-    # Använd den förenklade funktionen för rapportering
-    schedule.every().day.at("08:00").do(simple_status_report)
-    schedule.every().day.at("12:00").do(simple_status_report)
-    schedule.every().day.at("17:00").do(simple_status_report)
-    
-    # Veckorapport på måndagar
-    schedule.every().monday.at("09:00").do(lambda: send_to_slack(
-        "Veckostatistik", 
-        f"*ChargeNode AI Bot - Veckostatistik*\n\n{json.dumps(generate_monthly_stats(7), indent=2)}", 
-        "#3498db"
-    ))
-    
-    while True:
-        schedule.run_pending()
-        time.sleep(60)  # Kontrollera varje minut
+    # Flagga för att kontrollera om tråden ska fortsätta köra
+    running = True
+    
+    try:
+        # Använd den förenklade funktionen för rapportering
+        schedule.every().day.at("08:00").do(simple_status_report)
+        schedule.every().day.at("12:00").do(simple_status_report)
+        schedule.every().day.at("17:00").do(simple_status_report)
+        
+        # Veckorapport på måndagar
+        schedule.every().monday.at("09:00").do(lambda: send_to_slack(
+            "Veckostatistik", 
+            f"*ChargeNode AI Bot - Veckostatistik*\n\n{json.dumps(generate_monthly_stats(7), indent=2)}", 
+            "#3498db"
+        ))
+        
+        while running:
+            try:
+                schedule.run_pending()
+                time.sleep(60)  # Kontrollera varje minut
+            except Exception as e:
+                print(f"Fel i schemaläggaren: {e}")
+                time.sleep(300)  # Vänta 5 minuter vid fel
+    except Exception as e:
+        print(f"Kritiskt fel i schemaläggaren: {e}")
+    finally:
+        print("Schemaläggaren avslutad")
 
 # Starta schemaläggaren i en separat tråd
 scheduler_thread = threading.Thread(target=run_scheduler, daemon=True)
 scheduler_thread.start()
 
+# Registrera en atexit-funktion för att städa upp vid avslut
+
+def cleanup():
+    """Städa upp resurser vid avslut."""
+    print("Städar upp resurser...")
+    # Stäng scheduler om möjligt
+    schedule.clear()
+    
+    # Stäng CommitScheduler om den är aktiv
+    if 'scheduler' in globals() and scheduler:
+        try:
+            scheduler.stop()
+            print("CommitScheduler stoppad")
+        except Exception as e:
+            print(f"Kunde inte stoppa CommitScheduler: {e}")
+    
+    # Stäng eventuella öppna filer
+    try:
+        # Försök att stänga alla öppna filer
+        import gc
+        for obj in gc.get_objects():
+            if isinstance(obj, io.IOBase) and not obj.closed:
+                try:
+                    obj.close()
+                except:
+                    pass
+    except Exception as e:
+        print(f"Fel vid stängning av filer: {e}")
+
+atexit.register(cleanup)
+
 # Kör en statusrapport vid uppstart för att verifiera att allt fungerar
 try:
     print("Skickar en inledande statusrapport för att verifiera Slack-integrationen...")
@@ -565,35 +729,74 @@ except Exception as e:
 
 # Definiera respond och chat-relaterade funktioner före Gradio UI
 def respond(message, chat_history, request: gr.Request):
-    global last_log
+    global last_log, last_log_lock
+    
+    # Validera indata
+    if not message or not isinstance(message, str):
+        print(f"Varning: Ogiltigt meddelande: {type(message)}")
+        message = str(message) if message is not None else ""
+    
+    # Begränsa meddelandets längd för att förhindra överbelastning
+    if len(message) > 1000:
+        message = message[:1000] + "..."
+        print("Meddelande trunkerat på grund av längd")
+    
     start = time.time()
-    response = generate_answer(message)
+    try:
+        response = generate_answer(message)
+    except Exception as e:
+        print(f"Fel vid generering av svar: {e}")
+        response = f"Tyvärr uppstod ett tekniskt fel. Vänligen försök igen eller kontakta support@chargenode.eu. Felkod: {str(e)[:50]}"
+    
     elapsed = round(time.time() - start, 2)
 
     timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
     session_id = str(uuid.uuid4())
     
     # Använd session_id från tidigare logg om det finns
-    if last_log and 'session_id' in last_log:
-        session_id = last_log.get('session_id')
-        
-    user_id = request.client.host if request else "okänd"
-
-    ua_str = request.headers.get("user-agent", "")
-    ref = request.headers.get("referer", "")
-    ip = request.headers.get("x-forwarded-for", user_id).split(",")[0]
-    ua = parse_ua(ua_str)
-    browser = f"{ua.browser.family} {ua.browser.version_string}"
-    osys = f"{ua.os.family} {ua.os.version_string}"
+    with last_log_lock:
+        if last_log and 'session_id' in last_log:
+            session_id = last_log.get('session_id')
+    
+    # Säker hantering av request-objektet
+    user_id = "okänd"
+    ua_str = ""
+    ref = ""
+    ip = ""
+    
+    if request:
+        try:
+            user_id = request.client.host if hasattr(request.client, 'host') else "okänd"
+            ua_str = request.headers.get("user-agent", "") if hasattr(request, 'headers') else ""
+            ref = request.headers.get("referer", "") if hasattr(request, 'headers') else ""
+            ip = request.headers.get("x-forwarded-for", user_id).split(",")[0] if hasattr(request, 'headers') else user_id
+        except Exception as e:
+            print(f"Fel vid läsning av request-data: {e}")
+    
+    # Säker parsing av user agent
+    try:
+        ua = parse_ua(ua_str)
+        browser = f"{ua.browser.family} {ua.browser.version_string}"
+        osys = f"{ua.os.family} {ua.os.version_string}"
+    except Exception as e:
+        print(f"Fel vid parsing av user agent: {e}")
+        browser = "okänd"
+        osys = "okänd"
 
+    # Bestäm plattform
     platform = "webb"
-    if "chargenode.eu" in ref:
-        platform = "chargenode.eu"
-    elif "localhost" in ref:
-        platform = "test"
-    elif "app" in ref:
-        platform = "app"
+    try:
+        if ref:
+            if "chargenode.eu" in ref:
+                platform = "chargenode.eu"
+            elif "localhost" in ref:
+                platform = "test"
+            elif "app" in ref:
+                platform = "app"
+    except Exception as e:
+        print(f"Fel vid bestämning av plattform: {e}")
 
+    # Skapa loggdata
     log_data = {
         "timestamp": timestamp,
         "user_id": user_id,
@@ -609,7 +812,10 @@ def respond(message, chat_history, request: gr.Request):
 
     # Använd den förbättrade loggfunktionen
     safe_append_to_log(log_data)
-    last_log = log_data
+    
+    # Uppdatera last_log säkert
+    with last_log_lock:
+        last_log = log_data.copy()  # Använd en kopia för att undvika race conditions
 
     # Skicka varje konversation direkt till Slack
     try:
@@ -631,8 +837,17 @@ def respond(message, chat_history, request: gr.Request):
     except Exception as e:
         print(f"Kunde inte skicka konversation till Slack: {e}")
 
-    chat_history.append({"role": "user", "content": message})
-    chat_history.append({"role": "assistant", "content": response})
+    # Uppdatera chatthistorik
+    try:
+        chat_history.append({"role": "user", "content": message})
+        chat_history.append({"role": "assistant", "content": response})
+    except Exception as e:
+        print(f"Fel vid uppdatering av chatthistorik: {e}")
+        # Försök återställa chatthistoriken om något går fel
+        if not chat_history:
+            chat_history = []
+        chat_history.append({"role": "user", "content": message})
+        chat_history.append({"role": "assistant", "content": response})
     
     return "", chat_history
 
@@ -791,17 +1006,18 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
     
     # Lägg till anpassad JavaScript för att styra scrollning
     js_code = """
-    function scrollToTop() {
-        const chatContainer = document.querySelector('.gradio-container .message-wrap');
-        if (chatContainer) {
-            chatContainer.scrollTop = 0;
+    function scrollToLatestBotMessage() {
+        const latestBotMessage = document.querySelector('.gradio-container .message.bot:last-child');
+        if (latestBotMessage) {
+            // Scrolla så att det senaste botmeddelandet är synligt i toppen av chattrutan
+            latestBotMessage.scrollIntoView({block: 'start', behavior: 'smooth'});
         }
     }
 
     // Kör funktionen när nya meddelanden läggs till
     document.addEventListener('DOMNodeInserted', function(event) {
         if (event.target.classList && event.target.classList.contains('bot')) {
-            setTimeout(scrollToTop, 100);
+            setTimeout(scrollToLatestBotMessage, 100);
         }
     });
     """
@@ -841,4 +1057,4 @@ with gr.Blocks(css=custom_css, title="ChargeNode Kundtjänst") as app:
     )
 
 if __name__ == "__main__":
-    app.launch(share=True)
+    app.launch(share=True)