Cosa registrare durante prestiti, errori e salvataggi

Questa lezione appartiene al Modulo 19 — Logging e osservabilità.

Il lavoro continua il progetto guida, il Registro del laboratorio scolastico. In questa lezione impari cosa loggare con console.log, console.warn e console.error nei punti giusti del sistema, senza esporre dati sensibili.

Obiettivo della lezione

Aggiungere logging utile ai casi d’uso e all’infrastruttura del Registro: eventi significativi (prestito aperto), errori infrastrutturali (localStorage non disponibile), operazioni di salvataggio — senza loggare dati personali.

Alla fine devi avere: un set di istruzioni di logging nei punti chiave del Registro, con messaggi utili per il debug ma sicuri.

Tre livelli di logging

JavaScript ha tre funzioni principali per il logging:

• console.log — evento normale e informativo. Usalo per confermare che un’operazione è avvenuta.
• console.warn — situazione anomala ma gestita. Usalo quando il sistema continua a funzionare ma qualcosa non è ideale.
• console.error — errore grave, operazione fallita. Usalo quando un’operazione non può completarsi.

Il problema comune è usare solo console.log per tutto — inclusi gli errori — rendendo difficile distinguere cosa è normale da cosa è un problema.

Cosa loggare nel Registro

Queste sono le categorie di eventi da loggare nel Registro:

Prestiti e operazioni di dominio — loggare a livello Application quando un’operazione significativa va a buon fine:

• prestito aperto (con ID strumento, senza nome utente)
• prestito chiuso (con ID prestito)
• guasto segnalato (con ID strumento)

Errori infrastrutturali — loggare a livello Infrastructure quando localStorage fallisce:

• JSON corrotto o null al caricamento
• errore di scrittura in localStorage

Salvataggi — opzionale, utile durante il debug:

• salvataggio completato (con numero di record)

Non loggare mai:

• nomi di studenti o utenti
• dati personali identificabili
• stack trace completi nella console visibile all’utente

Procedura guidata

1. Apri i file dei casi d’uso in application/.
2. Aggiungi console.log per confermare le operazioni andate a buon fine.
3. Apri i file dell’adapter in infrastructure/.
4. Aggiungi console.warn per i dati anomali e console.error per i fallimenti.
5. Verifica che nessun log contenga dati personali.
6. Apri la console del browser e testa ogni operazione — i log devono essere chiari e utili.

Attività in classe

Compila questa scheda:

## Piano di logging

Caso d'uso: apriPrestito
Evento da loggare: prestito aperto
Livello (log/warn/error): log
Messaggio: "Prestito aperto — strumentoId: [id]"
Contiene dati personali? sì / no

Caso d'uso: chiudiPrestito
Evento da loggare:
Livello:
Messaggio:

Infrastruttura: caricaTutti
Evento da loggare: dati corrotti
Livello:
Messaggio:

Spiegazione guidata per studiare

Il logging non è decorativo. È la prima cosa che guardi quando qualcosa va storto — e la prima cosa che gli studenti durante la demo controllano quando un’operazione fallisce senza spiegazione.

Il punto chiave è: logga eventi, non dati. “Prestito aperto per strumentoId str-002” è un evento. “Prestito aperto da Mario Rossi per il Multimetro” è un dato personale. La differenza è che il dato personale può identificare una persona, l’evento no.

Nel Registro scolastico, il rischio non è alto — ma prendere l’abitudine giusta fin dall’inizio è la scelta corretta.

Passo per passo nel progetto

1. Aggiungi logging al caso d’uso apriPrestito:

// application/apriPrestito.js
export function apriPrestito({ strumentoId }, archivioStrumenti, archivioPrestiti) {
  const strumenti = archivioStrumenti.caricaTutti();
  const strumento = strumenti.find(s => s.id === strumentoId);

  if (!strumento) throw new Error("STRUMENTO_NON_TROVATO");
  if (strumento.stato !== "disponibile") throw new Error("STRUMENTO_NON_DISPONIBILE");

  strumento.stato = "in-prestito";
  archivioStrumenti.salva(strumenti);

  const prestiti = archivioPrestiti.caricaTutti();
  const nuovoPrestito = {
    id: crypto.randomUUID(),
    strumentoId,
    dataApertura: new Date().toISOString().split("T")[0],
    dataChiusura: null
  };
  prestiti.push(nuovoPrestito);
  archivioPrestiti.salva(prestiti);

  console.log(`Prestito aperto — strumentoId: ${strumentoId}, prestitoId: ${nuovoPrestito.id}`);
  return nuovoPrestito;
}

1. Aggiungi logging al caso d’uso chiudiPrestito:

// application/chiudiPrestito.js
export function chiudiPrestito({ strumentoId }, archivioStrumenti, archivioPrestiti) {
  const prestiti = archivioPrestiti.caricaTutti();
  const prestito = prestiti.find(p => p.strumentoId === strumentoId && !p.dataChiusura);

  if (!prestito) throw new Error("PRESTITO_NON_TROVATO");

  prestito.dataChiusura = new Date().toISOString().split("T")[0];
  archivioPrestiti.salva(prestiti);

  const strumenti = archivioStrumenti.caricaTutti();
  const strumento = strumenti.find(s => s.id === strumentoId);
  if (strumento) {
    strumento.stato = "disponibile";
    archivioStrumenti.salva(strumenti);
  }

  console.log(`Prestito chiuso — prestitoId: ${prestito.id}, strumentoId: ${strumentoId}`);
}

1. Aggiungi logging all’adapter localStorage per errori infrastrutturali:

// infrastructure/archivioStrumentiLocalStorage.js
const CHIAVE = "registro_strumenti";

export function caricaTutti() {
  try {
    const raw = localStorage.getItem(CHIAVE);
    if (!raw) {
      console.warn("caricaTutti: nessun dato in localStorage, ritorno array vuoto");
      return [];
    }
    const dati = JSON.parse(raw);
    if (!Array.isArray(dati)) {
      console.warn("caricaTutti: formato non valido in localStorage, ritorno array vuoto");
      return [];
    }
    return dati.map(dtoToStrumento);
  } catch (errore) {
    console.error("caricaTutti: errore di lettura localStorage —", errore.message);
    return [];
  }
}

export function salva(strumenti) {
  try {
    const dtos = strumenti.map(strumentoToDTO);
    localStorage.setItem(CHIAVE, JSON.stringify(dtos));
    console.log(`salva: ${strumenti.length} strumenti salvati in localStorage`);
  } catch (errore) {
    console.error("salva: errore di scrittura localStorage —", errore.message);
    throw new Error("ARCHIVIO_NON_DISPONIBILE");
  }
}

1. Verifica nella console del browser:
   • apri DevTools (F12) → Console
   • presta uno strumento → deve apparire “Prestito aperto — strumentoId: …”
   • restituiscilo → deve apparire “Prestito chiuso — …”
   • ricarica la pagina → non deve apparire nessun warning (i dati sono validi)

Esempio JS — cosa NON loggare

// SBAGLIATO — logga dati potenzialmente personali
console.log(`Prestito aperto da ${nomeutente} per ${strumento.nome}`);
console.log("Dati utente:", { nome, cognome, classe });
console.error("Errore:", errore.stack); // stack trace completo visibile a tutti

// CORRETTO — logga solo identificatori e stati
console.log(`Prestito aperto — strumentoId: ${strumentoId}`);
console.error("Errore infrastrutturale:", errore.message); // solo il messaggio, non lo stack

Prova di comprensione

Rispondi per iscritto:

• Qual è la differenza tra console.log, console.warn e console.error?
• Perché loggare l’ID di uno strumento è OK ma loggare il nome dell’utente non lo è?
• Dove nel progetto metti il log per “prestito aperto” — nel caso d’uso o nell’adapter?
• Se vedi console.warn("caricaTutti: nessun dato in localStorage") alla prima apertura dell’app, è un problema?

Errori da evitare

• usare console.log per tutto, inclusi gli errori gravi;
• loggare dati personali (nome utente, email, classe);
• lasciare il log del salvataggio attivo in produzione — può essere verboso;
• non loggare mai nulla — senza log, il debug diventa quasi impossibile.

Prodotto da consegnare

I file dei casi d’uso e dell’adapter aggiornati con il logging appropriato. Come verifica: apri la console del browser e esegui le tre operazioni principali — ogni operazione deve produrre un log chiaro e utile.

Checklist di chiusura

• ogni operazione significativa (apri prestito, chiudi prestito, segnala guasto) produce un console.log;
• gli errori infrastrutturali producono console.error con il messaggio dell’errore;
• i dati anomali (localStorage vuoto, formato non valido) producono console.warn;
• nessun log contiene dati personali;
• i log sono visibili e leggibili nella console del browser durante la demo.

Risultato atteso

Ho aggiunto logging ai casi d'uso apriPrestito e chiudiPrestito.
Ho aggiunto logging all'adapter localStorage per errori e warning.
Nella console del browser vedo: prestito aperto, prestito chiuso, salvataggio completato.
Nessun log contiene dati personali — solo ID e stati.