Privacy & compliance · 14 min lezen
BSN in logs en error tracking — privacy-first redaction patterns voor Sentry, Datadog en Splunk
Door Alex · Gepubliceerd 24 april 2026
Een BSN-nummer dat onbedoeld in een error log of APM-trace belandt, kan onder de AVG een datalek zijn, zeker als mensen zonder grondslag dat log kunnen inzien. Het gebeurt makkelijker dan je denkt: een mislukt request met een BSN in de body, een SQL-fout die de waarde van een sleutel noemt, een console.log(req.body) die is blijven staan. Dit artikel behandelt waar BSN-lekken ontstaan, waarom naïeve regex-redactie tekort schiet en hoe je in Sentry, Datadog en Splunk een robuuste redaction pipeline inricht — inclusief een elfproef-gate die false positives terugdringt.
1. Waar BSN-nummers onbedoeld in logs terechtkomen
De typische routes naar een log zijn voorspelbaar, maar de meeste teams hebben niet alle vier afgedekt:
- Request bodies bij validatiefouten. Een formulier met een BSN-veld faalt op bijvoorbeeld een te korte postcode; de validator logt de hele body om te helpen debuggen. De BSN zit erbij.
- Foutmeldingen en stack traces. Validatiefouten bevatten vaak de ingevoerde waarde (Pydantic in FastAPI zet de input in de foutmelding, Spring noemt de waarde bij een conversiefout). En wie in
getKlant(bsn: string)een fout gooit met het BSN in de tekst, krijgt het BSN in de trace. - URL-paden en query-strings.
GET /api/klant/123456782is geen goed API-ontwerp, maar komt voor — en access logs vangen de volledige URL. - SQL-errors met waarden. PostgreSQL noemt bij een unique-violation de sleutelwaarde in de foutdetails (Key (bsn)=(...) already exists).
log_statement = 'all'maakt dit nog erger. - Third-party SDK's. Payment-providers en identity-services sturen webhook-payloads met BSN-velden; als jouw ingress-logger die payload JSON-logt, zit het in je observability stack.
2. Waarom een simpele regex niet genoeg is
De voor de hand liggende aanpak is een regex op 9 cijfers: \d{9}. Die heeft twee problemen tegelijk: hij mist echte BSN's en redigeert data die geen BSN is.
False negatives.BSN's worden in formulieren en documenten vaak geformatteerd: met spaties (123 456 782), met punten (1234.56.782), met liggende streepjes, of zonder voorloopnul als 8 cijfers (12345672 in plaats van 012345672). Een pure \d{9} vangt die varianten niet.
False positives. In logs staan veel getallen van 9 cijfers die géén BSN zijn: transactie- en ordernummers, oude rekeningnummers en klantnummers. Een pure \d{9} zonder woordgrenzen pakt bovendien 9 cijfers midden uit een langer getal, zoals een timestamp in milliseconden (13 cijfers) of het rekeningnummer in een IBAN. Een willekeurig getal van 9 cijfers haalt maar in ongeveer 1 op de 11 gevallen de elfproef; met een elfproef-gate achter de regex blijft dus ruwweg 91 % van die kandidaten ongemoeid.
De les: regex is een kandidaatselector, geen validator. Een tweede stap — de elfproef — is nodig om echt BSN te onderscheiden van toevallig 9-cijferige ruis.
3. De elfproef als gate
De Nederlandse BSN-elfproef is een gewogen som: vermenigvuldig elk cijfer met de gewichten 9, 8, 7, 6, 5, 4, 3, 2, -1 (het laatste cijfer telt negatief), sommeer, en deel door 11. Alleen als de som deelbaar is door 11 én groter is dan 0, is het een geldig BSN. Zie ons elfproef-artikel voor de wiskundige onderbouwing.
Omdat ongeveer 1-op-de-11 random 9-cijferige getallen toevallig de elfproef doorstaan (≈9 %), is de gate niet perfect: een oud rekeningnummer als 417164300 haalt toevallig ook de elfproef en wordt gemaskeerd. Maar de overgrote meerderheid van de andere cijferreeksen blijft ongemoeid. Je stacktraces blijven leesbaar en je transactie-ID's intact; alleen echte BSN's (plus die ≈ 9 % toevallig geldige getallen) worden gemaskeerd. Voor logs is dat de juiste balans.
export function isValidBsn(raw: string): boolean {
const digits = raw.replace(/\D/g, '');
if (digits.length !== 9) return false;
const weights = [9, 8, 7, 6, 5, 4, 3, 2, -1];
let sum = 0;
for (let i = 0; i < 9; i++) sum += Number(digits[i]) * weights[i];
return sum > 0 && sum % 11 === 0;
}Hoe duur is die gate? In onze meting (Node 22, Intel Core i7-14650HX) kost een aanroep van isValidBsn ongeveer 50 nanoseconden. Een logregel van zo'n 100 tekens met één kandidaat scannen en controleren kost ongeveer 0,4 microseconde, tegen 0,2 microseconde voor alleen de regex. In een log-pipeline is dat verwaarloosbaar.
4. Sentry — een complete beforeSend hook
Sentry biedt een beforeSend hook die wordt aangeroepen vóór elke event-upload. Daarin kan je alle strings in het event-graph scannen en BSN-kandidaten maskeren. De hook hieronder is Node-SDK specifiek, maar hetzelfde patroon werkt in de browser-SDK.
import * as Sentry from '@sentry/node';
import { isValidBsn } from './bsn';
// 9 cijfers aaneen, of als 123 456 782 / 123.456.782 / 1234.56.782
const BSN_CANDIDATE =
/\b(?:\d{9}|\d{3}[ .-]\d{3}[ .-]\d{3}|\d{4}[ .]\d{2}[ .]\d{3})\b/g;
function redactBsn(input: string): string {
return input.replace(BSN_CANDIDATE, (match) =>
isValidBsn(match) ? '[REDACTED_BSN]' : match,
);
}
function walk(value: unknown, depth = 0): unknown {
if (depth > 10) return value;
if (typeof value === 'string') return redactBsn(value);
if (Array.isArray(value)) return value.map((v) => walk(v, depth + 1));
if (value && typeof value === 'object') {
const out: Record<string, unknown> = {};
for (const [k, v] of Object.entries(value)) out[k] = walk(v, depth + 1);
return out;
}
return value;
}
Sentry.init({
dsn: process.env.SENTRY_DSN,
beforeSend(event) {
// Message
if (event.message) event.message = redactBsn(event.message);
// Exception values
event.exception?.values?.forEach((ex) => {
if (ex.value) ex.value = redactBsn(ex.value);
});
// Breadcrumbs
event.breadcrumbs = event.breadcrumbs?.map((bc) => ({
...bc,
message: bc.message ? redactBsn(bc.message) : bc.message,
data: walk(bc.data) as typeof bc.data,
}));
// Request payload
if (event.request?.data) event.request.data = walk(event.request.data);
if (event.request?.query_string) {
event.request.query_string = walk(
event.request.query_string,
) as typeof event.request.query_string;
}
// Extra en contexts
event.extra = walk(event.extra) as typeof event.extra;
event.contexts = walk(event.contexts) as typeof event.contexts;
return event;
},
});Drie aandachtspunten bij deze hook. Ten eerste beperkt de walk een diepte van 10, om pathologische circulaire structuren af te vangen. Sentry doet intern ook truncation, maar de gate hier voorkomt onbedoelde recursie-fouten in je eigen hook. Ten tweede herkent de regex naast 9 aaneengesloten cijfers ook de gangbare notaties (123 456 782, 123.456.782 en 1234.56.782). Door de woordgrenzen aan beide kanten pakt hij geen 9 cijfers midden uit een langer getal of uit een IBAN. Wil je ook BSN's zonder voorloopnul vangen, voeg dan een alternatief voor 8 cijfers toe en vul in de gate eerst aan tot 9 cijfers; dan worden ook datums als 20240115 kandidaat, maar de elfproef laat de meeste daarvan staan. Ten derdeis de elfproef pas de tweede stap: alleen getallen die de elfproef halen, worden gemaskeerd, zodat order-ID's en timestamps leesbaar blijven. Let op: beforeSend geldt voor errors; voor performance-transacties is er beforeSendTransaction.
5. Datadog — Agent log-pipeline redaction
Datadog kan op twee plekken redigeren: in de Agent, vóór verzending, en server-side met de Sensitive Data Scanner. Scrubben in de Agent is veiliger, omdat het BSN dan nooit naar Datadog wordt verstuurd.
In datadog.yaml configureer je log scrubbing als volgt:
logs_config:
processing_rules:
- type: mask_sequences
name: mask_bsn_candidate
pattern: '\b(?:\d{9}|\d{3}[ .-]\d{3}[ .-]\d{3}|\d{4}[ .]\d{2}[ .]\d{3})\b'
replace_placeholder: '[REDACTED_BSN_CANDIDATE]'
# APM-traces: query string en padsegmenten met cijfers uit http.url halen
apm_config:
obfuscation:
http:
remove_query_string: true
remove_paths_with_digits: trueTwee beperkingen om bewust van te zijn. De Agent kan géén elfproef uitvoeren: het is pure regex-scrubbing. Dat betekent meer false positives (ook order-ID's van 9 cijfers worden gemaskeerd), maar dat is een acceptabele prijs voor scrubbing vóór verzending. Voor applicatie-logs waar je wél selectief wilt zijn, doe je de elfproef-gate in de applicatie zelf (zie sectie 7) en laat je de Agent als vangnet dienen. Letterlijke waarden in SQL-queries van APM-traces vervangt de Agent standaard al door een vraagteken.
Server-side kun je daarnaast de Sensitive Data Scanner van Datadog gebruiken: een scanregel met een eigen regex die gevonden waarden maskeert of hasht. Voor velden die gestructureerd binnenkomen (bijvoorbeeld attributes.user.bsn) is het betrouwbaarder om het hele veld weg te laten of te maskeren dan om op waarde-niveau te redigeren.
6. Splunk — SPL rex + sedcmd op ingest
Splunk redigeert op twee plekken: op ingest via SEDCMD in props.conf (of een transform in transforms.conf), en op search-time via rex. Op ingest is de voorkeur: BSN's komen dan nooit in de index. SEDCMD werkt op de indexer of een heavy forwarder, niet op een universal forwarder.
props.conf (per sourcetype):
[app_json_logs]
SEDCMD-bsn_mask = s/\b(?:\d{9}|\d{3}[ .-]\d{3}[ .-]\d{3}|\d{4}[ .]\d{2}[ .]\d{3})\b/[REDACTED_BSN]/gSearch-time redactie van bestaande geïndexeerde events (alleen in de zoekresultaten; de index zelf blijft ongewijzigd) kan via rex met mode=sed:
index=app sourcetype=app_json_logs
| rex field=_raw mode=sed "s/\b(?:\d{9}|\d{3}[ .-]\d{3}[ .-]\d{3}|\d{4}[ .]\d{2}[ .]\d{3})\b/[REDACTED_BSN]/g"
| table _time host _rawOmdat Splunk geen elfproef-extensie kent in stock-installaties, zijn er twee strategieën. Een: maskeer op ingest alles wat op een BSN lijkt (minder kans dat een BSN ontsnapt, meer false positives; notaties die de regex niet kent, glippen er alsnog door). Dit is wat bovenstaande config doet. Twee: draai de elfproef-gate in de log-producent (application logger) vóórdat de events bij Splunk aankomen; Splunk ziet dan alleen al-geredigeerde regels. Voor multi-tenant setups is optie twee veiliger: je gaat er niet vanuit dat elke bron op Splunk een correct props-transform heeft.
7. Structured logging — waarom JSON-loggers risico's beperken
Tekst-loggers als console.log en unformatted logging.info veranderen alles tot één grote string — redactie moet dan over vrije tekst, wat regex-gebonden is. Structured loggers loggen velden, en dat maakt het mogelijk om op veldnaam te redigeren (veel betrouwbaarder dan op waarde).
Node.js — pino heeft een ingebouwde redact-optie die veldpaden ondersteunt:
import pino from 'pino';
export const logger = pino({
redact: {
paths: [
'bsn',
'*.bsn',
'req.body.bsn',
'req.body.klant.bsn',
'user.burgerservicenummer',
],
censor: '[REDACTED_BSN]',
},
});Dit mist BSN's in vrije tekst (bv. een error.message), dus combineer met een formatter die redactBsn() uit sectie 4 toepast op de msg- en err.stack-velden.
Python — structlog via een processor:
import re
import structlog
BSN_RE = re.compile(
r"\b(?:\d{9}|\d{3}[ .-]\d{3}[ .-]\d{3}|\d{4}[ .]\d{2}[ .]\d{3})\b"
)
WEIGHTS = [9, 8, 7, 6, 5, 4, 3, 2, -1]
def _is_bsn(s: str) -> bool:
d = re.sub(r"\D", "", s)
if len(d) != 9:
return False
total = sum(int(c) * w for c, w in zip(d, WEIGHTS))
return total > 0 and total % 11 == 0
def redact_bsn(_, __, event_dict):
for k, v in list(event_dict.items()):
if isinstance(v, str):
event_dict[k] = BSN_RE.sub(
lambda m: "[REDACTED_BSN]" if _is_bsn(m.group(0)) else m.group(0),
v,
)
return event_dict
structlog.configure(processors=[redact_bsn, structlog.processors.JSONRenderer()])Java — Logback via een custom MessageConverter:
public class BsnMaskingConverter extends MessageConverter {
private static final Pattern P = Pattern.compile(
"\\b(?:\\d{9}|\\d{3}[ .-]\\d{3}[ .-]\\d{3}|\\d{4}[ .]\\d{2}[ .]\\d{3})\\b");
private static final int[] W = {9, 8, 7, 6, 5, 4, 3, 2, -1};
private boolean isBsn(String s) {
String d = s.replaceAll("\\D", "");
if (d.length() != 9) return false;
int sum = 0;
for (int i = 0; i < 9; i++) sum += Character.digit(d.charAt(i), 10) * W[i];
return sum > 0 && sum % 11 == 0;
}
@Override
public String convert(ILoggingEvent event) {
String msg = super.convert(event);
return P.matcher(msg).replaceAll(m -> isBsn(m.group()) ? "[REDACTED_BSN]" : m.group());
}
}Registreer de converter in logback.xml en gebruik %maskedMsg in je patroon.
Go — zerolog via een io.Writer die de uitvoer filtert (een zerolog-hook kan het bericht zelf niet aanpassen):
var (
bsnRe = regexp.MustCompile(`\b(?:\d{9}|\d{3}[ .-]\d{3}[ .-]\d{3}|\d{4}[ .]\d{2}[ .]\d{3})\b`)
nonDigit = regexp.MustCompile(`\D`)
weights = [9]int{9, 8, 7, 6, 5, 4, 3, 2, -1}
)
func isBsn(s []byte) bool {
digits := nonDigit.ReplaceAll(s, nil)
if len(digits) != 9 {
return false
}
sum := 0
for i, c := range digits {
sum += int(c-'0') * weights[i]
}
return sum > 0 && sum%11 == 0
}
// redactWriter maskeert BSN's in elke logregel voordat die wordt weggeschreven.
type redactWriter struct{ w io.Writer }
func (r redactWriter) Write(p []byte) (int, error) {
masked := bsnRe.ReplaceAllFunc(p, func(m []byte) []byte {
if isBsn(m) {
return []byte("[REDACTED_BSN]")
}
return m
})
if _, err := r.w.Write(masked); err != nil {
return 0, err
}
return len(p), nil
}
// Gebruik: logger := zerolog.New(redactWriter{os.Stdout}).With().Timestamp().Logger()8. AVG-aspect — wanneer wordt een log-lek een meldplicht?
Het BSN valt onder artikel 46 van de Uitvoeringswet AVG (UAVG): je mag het alleen gebruiken als een wet dat toestaat. Staat een BSN in een log dat toegankelijk is voor mensen zonder die grondslag, bijvoorbeeld het hele development-team terwijl maar een kleine groep productiegegevens mag inzien, dan kan er sprake zijn van een inbreuk in verband met persoonsgegevens in de zin van art. 4 lid 12 AVG.
Onder art. 33 AVG geldt een meldplicht bij de Autoriteit Persoonsgegevens binnen 72 uur na kennisname, tenzij het niet waarschijnlijk is dat de inbreuk een risico voor betrokkenen oplevert. Bij een BSN is dat risico er meestal: het nummer kan worden misbruikt voor identiteitsfraude en is wettelijk beschermd. Bij een hoog risico moet je onder art. 34 AVG ook de betrokkenen zelf informeren.
Bij een audit of na een incident komen steeds dezelfde vragen terug: (a) is er log-redactie ingericht, (b) is toegang tot logs gelogd en toetsbaar, (c) zijn logs versleuteld at-rest en in-transit, en (d) is er een retention policy die logs met (historisch) BSN ruimt zodra ze niet meer nodig zijn. Zie ons AVG-artikel over testomgevingen voor de bredere context.
9. Defense-in-depth — de drie lagen
Een productie-waardige aanpak combineert drie lagen, elk op een andere plek in de keten:
- Application layer — structured logger met veld-redactie (pino paths, structlog processor) plus formatter die de elfproef-gate draait op vrije tekst. Hier is de elfproef het makkelijkst in te bouwen, dus hier win je het meeste tegen false positives.
- Transport layer — Datadog Agent / Splunk heavy forwarder / Fluent Bit met regex-scrubbing als vangnet. Deze laag is agressiever (pure regex, geen elfproef) maar vangt logs af die de applicatie-laag heeft gemist.
- Storage layer — server-side scrubbing in Sentry (Advanced Data Scrubbing, als aanvulling op
beforeSend), de Sensitive Data Scanner van Datadog of SplunkSEDCMDop de indexer. Dit is de laatste verdedigingslinie. Search-time redactie maskeert alleen zoekresultaten; wat al in een index staat, moet je apart opruimen.
De kosten van deze stack zijn laag: de controle kost per regel weinig rekentijd (zie sectie 3) en het gaat om configuratie en een handvol functies. Daar staat tegenover dat je een meldplichtig datalek, reputatieschade en een mogelijke boete voorkomt.
10. Testen van je redaction pipeline
Een redaction laag die niet geverifieerd is, biedt schijnveiligheid. Bouw een regressietest met een vaste set van kandidaat-strings:
// Jest / Vitest
describe('redactBsn', () => {
it('redigeert plain 9-cijferig BSN', () => {
expect(redactBsn('user=123456782')).toBe('user=[REDACTED_BSN]');
});
it('redigeert BSN met spaties', () => {
expect(redactBsn('bsn: 123 456 782')).toBe('bsn: [REDACTED_BSN]');
});
it('redigeert BSN met punten', () => {
expect(redactBsn('123.456.782')).toBe('[REDACTED_BSN]');
expect(redactBsn('BSN 1234.56.782')).toBe('BSN [REDACTED_BSN]');
});
it('laat ordernummers die de elfproef niet halen intact', () => {
// 123456789 faalt elfproef
expect(redactBsn('order=123456789')).toBe('order=123456789');
});
it('laat timestamps in ms intact', () => {
expect(redactBsn('ts=1713960000000')).toBe('ts=1713960000000');
});
it('laat postcode+huisnummer intact', () => {
expect(redactBsn('1012AB-42')).toBe('1012AB-42');
});
it('laat telefoon- en IBAN-nummers intact', () => {
expect(redactBsn('tel=0612345678')).toBe('tel=0612345678');
expect(redactBsn('iban=NL91ABNA0417164300')).toBe('iban=NL91ABNA0417164300');
});
});Genereer de positieve fixtures met onze BSN-generator (willekeurige nummers die de elfproef halen) en valideer elke fixture met de BSN-validator, of een hele lijst in één keer met de bulk validator. Voeg de test toe aan je CI-pipeline zodat toekomstige wijzigingen aan logger-configs geen regressie introduceren.
11. Bronnen
- Verordening (EU) 2016/679 (AVG), art. 4 (definities), art. 33 (meldplicht datalekken), art. 34 (melding aan betrokkene).
- Uitvoeringswet AVG (UAVG), art. 46 — grondslag-eis voor BSN-verwerking.
- European Data Protection Board — Guidelines 9/2022 on personal data breach notification under GDPR; Autoriteit Persoonsgegevens — informatie over de meldplicht datalekken.
- Sentry SDK Reference — Filtering Events: beforeSend; Sentry — Advanced Data Scrubbing.
- Datadog Agent documentation — Scrub sensitive data from your logs; Datadog — Sensitive Data Scanner.
- Splunk Docs —
props.confSEDCMD en search-timerexmode=sed. - RFC 5424 — Syslog-protocol, grondslag voor structured-log velden.
Gerelateerde tools en artikelen
- BSN Generator — fixtures voor je redaction-tests
- BSN Validator — verifieer generatoroutput en log-kandidaten
- De elfproef ontleed — wiskundige basis van de BSN-check
- AVG in testomgevingen — bredere context over verwerkingsgrondslagen en boetes