#[tracing::instrument(fields(header), skip(self, buffer))]

        tracing::Span::current().record("header", tracing::field::debug(bstr::BStr::new(header)));

            tracing::debug!(?record, "unexpected header format: no account number line");

        let (account_number, _) = record[1].split_once(" / ")?;
        let Ok(account_number) = Iban::from_str(account_number) else {

        let Some((account_number, _)) = record[1].split_once(" / ") else {
            tracing::debug!(
                account_number = &record[1],
                "unexpected account number format: no separator"
            );

        let account_number = match Iban::from_str(account_number) {
            Ok(account_number) => account_number,
            Err(error) => {
                tracing::debug!(
                    account_number,
                    %error,
                    "unexpected account number format: invalid IBAN"
                );
                return None;
            }
        };

            tracing::debug!(?record, "unexpected header format: no from date line");

        let Ok(from_date) = Date::parse(&record[1], DATE_FORMAT) else {
            return None;

        let from_date = match Date::parse(&record[1], DATE_FORMAT) {
            Ok(from_date) => from_date,
            Err(error) => {
                tracing::debug!(
                    %error,
                    from_date = &record[1],
                    "unexpected date format for from date"
                );
                return None;
            }

            tracing::debug!(?record, "unexpected header format: no to date line");

        let Ok(to_date) = Date::parse(&record[1], DATE_FORMAT) else {
            return None;

        let to_date = match Date::parse(&record[1], DATE_FORMAT) {
            Ok(to_date) => to_date,
            Err(error) => {
                tracing::debug!(
                    %error,
                    to_date = &record[1],
                    "unexpected date format for to date"
                );
                return None;
            }

            tracing::debug!(?record, "unexpected header format: no balance line");

        let Ok(balance_date) = Date::parse(

        let balance_date = match Date::parse(

        ) else {
            return None;

        ) {
            Ok(balance_date) => balance_date,
            Err(error) => {
                tracing::debug!(
                    %error,
                    field = &record[0],
                    "unexpected header format: unexpected field header for balance",
                );
                return None;
            }

        let Ok(final_balance) = parse_german_amount(&record[1]) else {
            return None;

        let final_balance = match parse_german_amount(&record[1]) {
            Ok(final_balance) => final_balance,
            Err(error) => {
                tracing::debug!(
                    %error,
                    balance = &record[1],
                    "unexpected format for closing balance",
                );
                return None;
            }

            header.to_date.next_day().unwrap(),

            header.balance_date.next_day().unwrap(),

            Record::Statement(record) => vec![],

            Record::Statement(_record) => vec![],

tracing.workspace        = true

 "tracing",