# SQL Query Logging Implementation

## Overview

Il sistema di logging SQL è stato implementato per tracciare tutte le query eseguite dall'applicazione. Questo permette di monitorare le performance e debuggare eventuali problemi legati all'accesso ai dati.

## Implementazione

### 1. Classe SqlLogging

La classe `SqlLogging` è stata aggiunta in `DataAccessLayer` e gestisce il logging delle query SQL. Si trova in:
```plaintext
/root/Shared/DataAccessLayer/SqlLogging.cs
```

### 2. Funzionalità

Il logger registra le seguenti informazioni per ogni query:

* Timestamp dell'esecuzione
* Tipo di comando (Text, StoredProcedure)
* Query SQL eseguita
* Parametri e loro valori
* Tempo di esecuzione in millisecondi

### 3. Configurazione

I log vengono salvati automaticamente in:
```plaintext
{AppDomain.CurrentDomain.BaseDirectory}\SqlLogs\sql_log_YYYYMMDD.txt
```
Un nuovo file viene creato ogni giorno.

### 4. Esempio di Output

```plaintext
[2025-05-23 10:12:05.123]
Command Type: StoredProcedure
Command Text: sp_GetCustomerData
Parameters:
    @CustomerId (Int): 12345
    @Date (DateTime): 2025-05-23
Execution Time: 150ms
--------------------------------------------------------------------------------
```

### 5. Integrazione

Il logging è stato integrato in tutti i metodi di accesso ai dati della classe `DataAccessDE`:

* ExecuteReader
* ExecuteNonQuery
* ExecuteScalar
* Stored Procedures
* Query SQL dirette

### 6. Thread Safety

Il sistema di logging è thread-safe grazie all'utilizzo di:

* File giornalieri separati
* Lock durante la scrittura dei log
* StringBuilder per la composizione dei messaggi

### 7. Gestione Errori

* In caso di errori durante il logging, questi vengono catturati e non interferiscono con l'esecuzione normale dell'applicazione
* Gli errori di logging vengono scritti nel debug output usando `System.Diagnostics.Debug.WriteLine`

## Come Utilizzare

Non è necessaria alcuna configurazione aggiuntiva. Il logging è automaticamente attivo per tutte le query SQL eseguite attraverso il layer DataAccess.

## Performance Impact

* Il logging è progettato per avere un impatto minimo sulle performance
* La scrittura su file avviene in modo asincrono
* I file vengono suddivisi per giorno per evitare file troppo grandi

## Manutenzione

* I file di log vengono creati automaticamente nella cartella SqlLogs
* Si consiglia di implementare una policy di retention per i file di log più vecchi
* Monitorare periodicamente la dimensione della cartella SqlLogs

## FAQ

### Come posso stampare sul log le query eseguite?

Ci sono due approcci principali:

1. **ADO.NET Diretto (Implementato)**
   * Utilizza la classe `SqlLogging` che intercetta e logga automaticamente tutte le query
   * I log vengono salvati in file giornalieri nella cartella SqlLogs
   * Include dettagli come timestamp, parametri e tempi di esecuzione

2. **LINQ to SQL**

   ```csharp
   DataClassesStorTrimDataContext context = new DataClassesStorTrimDataContext();
   context.Log = new StringWriter(); // oppure qualsiasi TextWriter
   // oppure
   context.Log = Console.Out; // per vedere le query direttamente nella console
   ```
### Quale approccio è stato implementato?

È stato implementato l'approccio ADO.NET diretto perché:

* È l'approccio principale utilizzato nel progetto
* Offre maggior controllo sul logging
* Permette di tracciare tutte le query, inclusi i parametri e i tempi di esecuzione
* Supporta il logging thread-safe su file

### Come funziona il sistema di logging?

Il sistema utilizza extension methods su `SqlCommand` per intercettare automaticamente tutte le chiamate al database:

* `ExecuteNonQueryWithLogging()`
* `ExecuteReaderWithLogging()`
* `ExecuteScalarWithLogging()`

Ogni chiamata viene loggata con tutti i dettagli rilevanti in un file giornaliero.