Foutafhandeling in Apps Script

Basis try/catch/finally

Apps Script draait op de V8-runtime en gebruikt de standaard JavaScript-foutafhandeling. Elke onafgevangen fout stopt de scriptuitvoering en verschijnt in het uitvoeringslogboek (Execution log) in de editor.

function basisFoutafhandeling() {
  try {
    const data = haalDataOpVanApi();
    verwerkData(data);
  } catch(e) {
    Logger.log(`Fout: ${e.message}`);
    Logger.log(`Stack: ${e.stack}`);
    throw e;
  } finally {
    Logger.log('Altijd uitgevoerd, ook bij fout');
  }
}

function haalDataOpVanApi() {
  const response = UrlFetchApp.fetch('https://api.voorbeeld.nl/data', {
    muteHttpExceptions: true,
  });

  if (response.getResponseCode() !== 200) {
    throw new Error(`API-fout: HTTP ${response.getResponseCode()}`);
  }

  return JSON.parse(response.getContentText());
}

Aangepaste fouttypen

Door eigen fouttypen te definieren kun je in een catch-blok gericht reageren op het soort fout. Zet bijvoorbeeld een vlag herstelbaar op de fout, zodat een retry-laag later weet of opnieuw proberen zinvol is.

class ValidationFout extends Error {
  constructor(veld, bericht) {
    super(`Validatiefout in ${veld}: ${bericht}`);
    this.name = 'ValidationFout';
    this.veld = veld;
  }
}

class ApiVerbindingsFout extends Error {
  constructor(statusCode, url) {
    super(`API fout ${statusCode} bij ${url}`);
    this.name = 'ApiVerbindingsFout';
    this.statusCode = statusCode;
    this.url = url;
    this.herstelbaar = statusCode >= 500;
  }
}

function verwerkInputData(data) {
  if (!data.naam || data.naam.trim() === '') {
    throw new ValidationFout('naam', 'Naam is verplicht');
  }
  if (!data.email || !data.email.includes('@')) {
    throw new ValidationFout('email', 'Ongeldig e-mailadres');
  }
}

Fouttype-specifieke afhandeling

function verwerkMetFoutafhandeling(invoer) {
  try {
    verwerkInputData(invoer);
    const resultaat = verwerkVoorApi(invoer);
    return {succes: true, data: resultaat};
  } catch(e) {
    if (e.name === 'ValidationFout') {
      Logger.log(`Validatiefout, geen retry nodig: ${e.message}`);
      return {succes: false, fout: e.message, herstelbaar: false};
    }

    if (e.name === 'ApiVerbindingsFout') {
      if (e.herstelbaar) {
        Logger.log('Serverfout, retry mogelijk');
        return {succes: false, fout: e.message, herstelbaar: true};
      }
      Logger.log('Clientfout, geen retry');
      return {succes: false, fout: e.message, herstelbaar: false};
    }

    Logger.log(`Onverwachte fout: ${e.message}`);
    throw e;
  }
}

Retry-logica voor tijdelijke fouten

Tijdelijke (transiente) fouten zoals een 500-status of een tijdelijke timeout lossen vaak vanzelf op. Een retry met oplopende wachttijd (exponentiele of lineaire backoff) maakt je script veerkrachtig zonder dat je een externe API overbelast.

function metRetry(fn, maxPogingen = 3, wachtMs = 1000) {
  let laatsteFout;

  for (let poging = 1; poging <= maxPogingen; poging++) {
    try {
      return fn();
    } catch(e) {
      laatsteFout = e;

      const herstelbaar = e.name === 'ApiVerbindingsFout' && e.herstelbaar;
      if (!herstelbaar || poging === maxPogingen) {
        break;
      }

      Logger.log(`Poging ${poging} mislukt: ${e.message}. Wachten ${wachtMs * poging}ms`);
      Utilities.sleep(wachtMs * poging);
    }
  }

  throw laatsteFout;
}

function roepApiAanMetRetry() {
  return metRetry(() => {
    const response = UrlFetchApp.fetch('https://api.voorbeeld.nl/data', {muteHttpExceptions: true});
    if (response.getResponseCode() >= 500) {
      throw new ApiVerbindingsFout(response.getResponseCode(), 'https://api.voorbeeld.nl/data');
    }
    return JSON.parse(response.getContentText());
  });
}

Batch-verwerking met gedeeltelijke foutafhandeling

Bij het verwerken van een lijst wil je vaak dat een fout in een enkel item de hele batch niet stopt. Vang per item op, verzamel de resultaten en rapporteer aan het eind wat geslaagd en wat mislukt is.

function verwerkBatchMetFouten(items) {
  const resultaten = {
    geslaagd: [],
    mislukt: [],
    totaal: items.length,
  };

  items.forEach((item, idx) => {
    try {
      const resultaat = verwerkEnkelItem(item);
      resultaten.geslaagd.push({idx, item, resultaat});
    } catch(e) {
      resultaten.mislukt.push({idx, item, fout: e.message});
      Logger.log(`Item ${idx} mislukt: ${e.message}`);
    }
  });

  Logger.log(`Geslaagd: ${resultaten.geslaagd.length}, Mislukt: ${resultaten.mislukt.length}`);
  return resultaten;
}

function verwerkEnkelItem(item) {
  if (!item.naam) throw new Error('Naam ontbreekt');
  return {verwerkt: true, naam: item.naam};
}

Globale foutafhandelaar voor triggers

Bij een tijdgestuurde trigger is er niemand die het foutscherm ziet. Wikkel de logica daarom in een wrapper die fouten opvangt, naar Cloud Logging schrijft met console.error() en de beheerder mailt. De wrapper gooit zelf geen fout, zodat de trigger-run netjes eindigt.

function triggerWrapper(fn, functieNaam) {
  const startTijd = Date.now();
  try {
    fn();
    Logger.log(`${functieNaam} succesvol in ${Date.now() - startTijd}ms`);
  } catch(e) {
    const melding = `Trigger fout in ${functieNaam}: ${e.message}`;
    console.error(melding);

    try {
      GmailApp.sendEmail(
        PropertiesService.getScriptProperties().getProperty('ADMIN_EMAIL') || 'admin@bedrijf.nl',
        `Script Fout: ${functieNaam}`,
        `${melding}

Stack:
${e.stack}`
      );
    } catch(mailFout) {
      console.error('Kon foutmelding niet verzenden: ' + mailFout.message);
    }
  }
}

function dagelijkseVerwerking() {
  triggerWrapper(() => {
    Logger.log('Dagelijkse verwerking gestart');
  }, 'dagelijkseVerwerking');
}

Berichten die je met console.error() schrijft, verschijnen in Cloud Logging (voorheen Stackdriver) en in het Executions-paneel van de editor. Vink in de Google Cloud-instellingen van je project "Log uncaught exceptions" aan om onafgevangen fouten ook automatisch in Error Reporting te zien.

Goede foutafhandeling is het verschil tussen een productie-script en een fragiel experiment. Investeer in consistente patronen voor alle scripts die automatisch worden uitgevoerd, dan weet je bij elke trigger-run precies wat er goed en wat er fout ging.