@abyss-project/monitor 2.2.1 → 2.4.0

package/dist/__tests__/log-shipper.test.js

@@ -0,0 +1,1040 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const uuid_1 = require("uuid");
+const log_shipper_model_1 = require("../models/log-shipper.model");
+const log_spool_model_1 = require("../models/log-spool.model");
+const __1 = require("..");
+const applicationLogApi = __importStar(require("../api/application-log.api"));
+const types_1 = require("../types");
+const APPLICATION_ID = 'app-1';
+const ACK = { data: { created: 1, deduped: 0 } };
+const REFUSED = '[refusé]';
+const makeLog = (message, dateValue = new Date()) => ({ message, level: types_1.LogLevel.LOG, processId: '1', dateValue, clientLogId: (0, uuid_1.v4)() });
+const httpError = (status) => Object.assign(new Error(`HTTP ${status}`), { response: { status } });
+const spooledFiles = (base) => {
+    const directory = path.join(base, APPLICATION_ID);
+    return fs.existsSync(directory)
+        ? fs.readdirSync(directory).filter((f) => !f.startsWith('.'))
+        : [];
+};
+const settle = () => new Promise((resolve) => setImmediate(resolve));
+const useFakeClock = () => {
+    jest.useFakeTimers({
+        now: Date.now(),
+        doNotFake: ['nextTick', 'setImmediate', 'queueMicrotask'],
+    });
+};
+const deferred = () => {
+    let resolve;
+    const promise = new Promise((res) => {
+        resolve = res;
+    });
+    return { promise, resolve };
+};
+const ORIGINAL_SPOOL_DIRECTORY_ENV = process.env[log_shipper_model_1.SPOOL_DIRECTORY_ENV];
+describe('LogShipper', () => {
+    let base;
+    let sendBulk;
+    const shippers = [];
+    const messagesOf = (call) => sendBulk.mock.calls[call][2].logs.map((l) => l.message);
+    const allShipped = () => sendBulk.mock.calls.flatMap((call) => call[2].logs.map((l) => l.message));
+    let accepted = [];
+    const refusingMarked = (status) => async (_params, _query, body) => {
+        if (body.logs.some((log) => log.message.includes(REFUSED))) {
+            throw httpError(status);
+        }
+        accepted.push(body);
+        return ACK;
+    };
+    const deliveredMessages = () => accepted.flatMap((body) => body.logs.map((log) => log.message)).sort();
+    beforeEach(() => {
+        accepted = [];
+        base = fs.mkdtempSync(path.join(os.tmpdir(), 'abyss-shipper-'));
+        __1.AbyssMonitorCore.setConfig({ applicationId: APPLICATION_ID, secretPublishToken: 'secret' });
+        sendBulk = jest
+            .spyOn(applicationLogApi, 'createBulkApplicationLog')
+            .mockResolvedValue({ data: { created: 0, deduped: 0 } });
+        jest.spyOn(console, 'error').mockImplementation(() => undefined);
+    });
+    afterEach(async () => {
+        shippers.splice(0).forEach((shipper) => shipper.stop());
+        await settle();
+        jest.useRealTimers();
+        jest.restoreAllMocks();
+        fs.rmSync(base, { recursive: true, force: true });
+        if (ORIGINAL_SPOOL_DIRECTORY_ENV === undefined) {
+            delete process.env[log_shipper_model_1.SPOOL_DIRECTORY_ENV];
+        }
+        else {
+            process.env[log_shipper_model_1.SPOOL_DIRECTORY_ENV] = ORIGINAL_SPOOL_DIRECTORY_ENV;
+        }
+    });
+    const shipperOn = (options = {}) => {
+        const shipper = new log_shipper_model_1.LogShipper({ spoolDirectory: base, flushIntervalMs: 60_000, ...options });
+        shippers.push(shipper);
+        return shipper;
+    };
+    it('regroupe plusieurs logs dans un seul POST', async () => {
+        const shipper = shipperOn();
+        shipper.enqueue(makeLog('a'));
+        shipper.enqueue(makeLog('b'));
+        await shipper.flush();
+        expect(sendBulk).toHaveBeenCalledTimes(1);
+        expect(sendBulk.mock.calls[0][0]).toEqual({ applicationId: APPLICATION_ID });
+        expect(sendBulk.mock.calls[0][1]).toEqual({ token: 'secret' });
+        expect(sendBulk.mock.calls[0][2].logs).toHaveLength(2);
+        expect(sendBulk.mock.calls[0][2].droppedCount).toBeNull();
+    });
+    it('un lot porte au moins une ligne, quel que soit maxBatchEntries', async () => {
+        useFakeClock();
+        const shipper = shipperOn({ maxBatchEntries: 0 });
+        shipper.enqueue(makeLog('a'));
+        shipper.enqueue(makeLog('b'));
+        await shipper.flush();
+        expect(messagesOf(0)).toEqual(['a']);
+        expect(messagesOf(1)).toEqual(['b']);
+    });
+    it('une file garde au moins une ligne, quel que soit maxQueueEntries', async () => {
+        const shipper = shipperOn({ maxQueueEntries: 0 });
+        shipper.enqueue(makeLog('a'));
+        shipper.enqueue(makeLog('b'));
+        await shipper.flush();
+        expect(allShipped()).toEqual(['b']);
+        expect(sendBulk.mock.calls[0][2].droppedCount).toBe(1);
+    });
+    it('remonte le nombre de logs jetés par la file dans le lot suivant', async () => {
+        const shipper = shipperOn({ maxQueueEntries: 1 });
+        shipper.enqueue(makeLog('a'));
+        shipper.enqueue(makeLog('b'));
+        await shipper.flush();
+        expect(sendBulk.mock.calls[0][2].droppedCount).toBe(1);
+    });
+    it('supprime le fichier de spool après un ACK', async () => {
+        const shipper = shipperOn();
+        shipper.enqueue(makeLog('a'));
+        await shipper.flush();
+        expect(spooledFiles(base)).toHaveLength(0);
+    });
+    it('garde le lot sur disque sur un échec transitoire', async () => {
+        sendBulk.mockRejectedValue(httpError(503));
+        const shipper = shipperOn();
+        shipper.enqueue(makeLog('a'));
+        await shipper.flush();
+        expect(spooledFiles(base)).toHaveLength(1);
+    });
+    it('jette un lot refusé définitivement, et le dit dans le lot suivant', async () => {
+        sendBulk.mockImplementation(refusingMarked(400));
+        const shipper = shipperOn();
+        shipper.enqueue(makeLog(`a ${REFUSED}`));
+        shipper.enqueue(makeLog(`b ${REFUSED}`));
+        await shipper.flush();
+        expect(spooledFiles(base)).toHaveLength(0);
+        shipper.enqueue(makeLog('c'));
+        await shipper.flush();
+        expect(sendBulk).toHaveBeenCalledTimes(4);
+        expect(messagesOf(3)).toEqual(['c']);
+        expect(sendBulk.mock.calls[3][2].droppedCount).toBe(2);
+    });
+    it("un lot refusé pour une seule ligne livre les autres et ne jette qu'elle", async () => {
+        sendBulk.mockImplementation(refusingMarked(400));
+        const shipper = shipperOn();
+        ['a', 'b', `c ${REFUSED}`, 'd'].forEach((message) => shipper.enqueue(makeLog(message)));
+        await shipper.flush();
+        expect(deliveredMessages()).toEqual(['a', 'b', 'd']);
+        expect(sendBulk.mock.calls.map((call) => call[2].logs.length)).toEqual([4, 2, 2, 1, 1]);
+        expect(spooledFiles(base)).toHaveLength(0);
+        shipper.enqueue(makeLog('e'));
+        await shipper.flush();
+        expect(messagesOf(5)).toEqual(['e']);
+        expect(sendBulk.mock.calls[5][2].droppedCount).toBe(1);
+    });
+    it('une ligne sans message (logger.error(undefined)) refusée en 422 est isolée, jetée et comptée', async () => {
+        sendBulk.mockImplementation(async (_params, _query, body) => {
+            if (body.logs.some((log) => log.message === undefined)) {
+                throw httpError(422);
+            }
+            accepted.push(body);
+            return ACK;
+        });
+        const shipper = shipperOn();
+        const withoutMessage = { ...makeLog('x'), message: undefined };
+        shipper.enqueue(makeLog('a'));
+        shipper.enqueue(withoutMessage);
+        shipper.enqueue(makeLog('b'));
+        await shipper.flush();
+        shipper.enqueue(makeLog('c'));
+        await shipper.flush();
+        expect(deliveredMessages()).toEqual(['a', 'b', 'c']);
+        expect(spooledFiles(base)).toHaveLength(0);
+        expect(accepted[accepted.length - 1].droppedCount).toBe(1);
+    });
+    it('une ligne seule refusée est jetée sans découpe', async () => {
+        sendBulk.mockImplementation(refusingMarked(422));
+        const shipper = shipperOn();
+        shipper.enqueue(makeLog(`seule ${REFUSED}`));
+        await shipper.flush();
+        expect(sendBulk).toHaveBeenCalledTimes(1);
+        shipper.enqueue(makeLog('suivante'));
+        await shipper.flush();
+        expect(sendBulk).toHaveBeenCalledTimes(2);
+        expect(sendBulk.mock.calls[1][2].droppedCount).toBe(1);
+    });
+    it('un 413 sur un lot de deux le coupe en deux envois d une ligne', async () => {
+        sendBulk.mockImplementation(async (_params, _query, body) => {
+            if (body.logs.length > 1) {
+                throw httpError(413);
+            }
+            return ACK;
+        });
+        const shipper = shipperOn();
+        shipper.enqueue(makeLog('a'));
+        shipper.enqueue(makeLog('b'));
+        await shipper.flush();
+        expect(sendBulk.mock.calls.map((call) => call[2].logs.length)).toEqual([2, 1, 1]);
+        expect(messagesOf(1)).toEqual(['a']);
+        expect(messagesOf(2)).toEqual(['b']);
+        expect(spooledFiles(base)).toHaveLength(0);
+        shipper.enqueue(makeLog('c'));
+        await shipper.flush();
+        expect(sendBulk.mock.calls[3][2].droppedCount).toBeNull();
+    });
+    it('le rejeu d un fichier refusé pour une ligne livre les autres, puis supprime le fichier', async () => {
+        sendBulk.mockRejectedValueOnce(httpError(503));
+        const first = shipperOn();
+        ['a', `b ${REFUSED}`, 'c', 'd'].forEach((message) => first.enqueue(makeLog(message)));
+        await first.flush();
+        first.stop();
+        expect(spooledFiles(base)).toHaveLength(1);
+        sendBulk.mockImplementation(refusingMarked(400));
+        const second = shipperOn();
+        expect(await second.replaySpool()).toBe(1);
+        expect(spooledFiles(base)).toHaveLength(0);
+        expect(deliveredMessages()).toEqual(['a', 'c', 'd']);
+        second.enqueue(makeLog('e'));
+        await second.flush();
+        expect(accepted[accepted.length - 1].droppedCount).toBe(1);
+    });
+    it.each([
+        {
+            half: 'la seconde moitié',
+            failing: 'c,d',
+            deliveredFirst: ['a'],
+            deliveredInTheEnd: ['a', 'a', 'c', 'd', 'e', 'f'],
+        },
+        {
+            half: 'la première moitié',
+            failing: 'a',
+            deliveredFirst: [],
+            deliveredInTheEnd: ['a', 'c', 'd', 'e', 'f'],
+        },
+    ])('un échec transitoire dans $half de la découpe garde tout le lot, sans compter deux fois', async ({ failing, deliveredFirst, deliveredInTheEnd }) => {
+        let serverDown = true;
+        const server = refusingMarked(400);
+        sendBulk.mockImplementation(async (params, query, body) => {
+            if (serverDown && body.logs.map((log) => log.message).join() === failing) {
+                throw httpError(503);
+            }
+            return server(params, query, body);
+        });
+        const shipper = shipperOn();
+        ['a', `X ${REFUSED}`, 'c', 'd'].forEach((message) => shipper.enqueue(makeLog(message)));
+        await shipper.flush();
+        expect(spooledFiles(base)).toHaveLength(1);
+        expect(deliveredMessages()).toEqual(deliveredFirst);
+        serverDown = false;
+        shipper.enqueue(makeLog('e'));
+        await shipper.flush(3_000, { ignoreBackoff: true });
+        await settle();
+        shipper.enqueue(makeLog('f'));
+        await shipper.flush();
+        expect(spooledFiles(base)).toHaveLength(0);
+        expect(deliveredMessages()).toEqual(deliveredInTheEnd);
+        expect(accepted.reduce((sum, body) => sum + (body.droppedCount ?? 0), 0)).toBe(1);
+    });
+    it("un fichier dont toutes les lignes sont refusées est jeté, compté, et n'est pas « rejoué »", async () => {
+        sendBulk.mockRejectedValueOnce(httpError(503));
+        const first = shipperOn();
+        first.enqueue(makeLog(`x ${REFUSED}`));
+        first.enqueue(makeLog(`y ${REFUSED}`));
+        await first.flush();
+        first.stop();
+        sendBulk.mockImplementation(refusingMarked(400));
+        const second = shipperOn();
+        expect(await second.replaySpool()).toBe(0);
+        expect(spooledFiles(base)).toHaveLength(0);
+        second.enqueue(makeLog('z'));
+        await second.flush();
+        expect(accepted.map((body) => body.droppedCount)).toEqual([2]);
+    });
+    it(`un refus qui ne vise pas une ligne s'arrête à ${log_shipper_model_1.MAX_REFUSED_LINES_PER_BATCH} lignes refusées`, async () => {
+        useFakeClock();
+        sendBulk.mockRejectedValue(httpError(400));
+        const shipper = shipperOn();
+        for (let line = 0; line < 100; line += 1) {
+            shipper.enqueue(makeLog(`ligne ${line}`));
+        }
+        await shipper.flush();
+        expect(sendBulk.mock.calls.map((call) => call[2].logs.length)).toEqual([
+            100, 50, 25, 13, 7, 4, 2, 1, 1, 2, 1, 1, 3, 2, 1,
+        ]);
+        expect(sendBulk.mock.calls.length).toBeLessThanOrEqual(7 + 2 * log_shipper_model_1.MAX_REFUSED_LINES_PER_BATCH);
+        expect(spooledFiles(base)).toHaveLength(0);
+        sendBulk.mockImplementation(refusingMarked(400));
+        shipper.enqueue(makeLog('suivante'));
+        await shipper.flush();
+        expect(accepted.map((body) => body.droppedCount)).toEqual([100]);
+    });
+    it("à la sortie, le délai qui tombe au milieu d'une découpe garde le lot sur disque", async () => {
+        useFakeClock();
+        const server = refusingMarked(400);
+        sendBulk.mockImplementation(async (params, query, body) => {
+            jest.setSystemTime(Date.now() + 1_000);
+            return server(params, query, body);
+        });
+        const shipper = shipperOn();
+        ['a', 'b', `c ${REFUSED}`, 'd'].forEach((message) => shipper.enqueue(makeLog(message)));
+        await shipper.flush(1_500, { ignoreBackoff: true });
+        expect(sendBulk.mock.calls.map((call) => call[2].logs.length)).toEqual([4, 2]);
+        const [file] = spooledFiles(base);
+        const onDisk = fs
+            .readFileSync(path.join(base, APPLICATION_ID, file), 'utf8')
+            .split('\n')
+            .map((line) => JSON.parse(line).message);
+        expect(onDisk).toEqual(['a', 'b', `c ${REFUSED}`, 'd']);
+        sendBulk.mockImplementation(server);
+        const next = shipperOn();
+        expect(await next.replaySpool()).toBe(1);
+        expect(spooledFiles(base)).toHaveLength(0);
+        expect(deliveredMessages()).toEqual(['a', 'a', 'b', 'b', 'd']);
+        next.enqueue(makeLog('e'));
+        await next.flush();
+        expect(accepted[accepted.length - 1].droppedCount).toBe(1);
+    });
+    it('un flush ordinaire finit sa découpe même si son délai tombe au milieu', async () => {
+        useFakeClock();
+        const server = refusingMarked(400);
+        sendBulk.mockImplementation(async (params, query, body) => {
+            jest.setSystemTime(Date.now() + 1_000);
+            return server(params, query, body);
+        });
+        const shipper = shipperOn();
+        ['a', 'b', `c ${REFUSED}`, 'd'].forEach((message) => shipper.enqueue(makeLog(message)));
+        await shipper.flush(1_500);
+        expect(deliveredMessages()).toEqual(['a', 'b', 'd']);
+        expect(spooledFiles(base)).toHaveLength(0);
+    });
+    it("n'envoie rien pendant le recul, puis relit le spool sans attendre de redémarrage", async () => {
+        useFakeClock();
+        sendBulk.mockRejectedValueOnce(httpError(503));
+        const shipper = shipperOn();
+        shipper.enqueue(makeLog('pendant la panne'));
+        await shipper.flush();
+        expect(sendBulk).toHaveBeenCalledTimes(1);
+        shipper.enqueue(makeLog('toujours pendant la panne'));
+        await shipper.flush();
+        expect(await shipper.replaySpool()).toBe(0);
+        expect(sendBulk).toHaveBeenCalledTimes(1);
+        expect(spooledFiles(base)).toHaveLength(2);
+        jest.setSystemTime(Date.now() + log_shipper_model_1.BACKOFF_BASE_MS + 1);
+        shipper.enqueue(makeLog('après'));
+        await shipper.flush();
+        await settle();
+        expect(spooledFiles(base)).toHaveLength(0);
+        expect(allShipped()).toEqual(expect.arrayContaining(['pendant la panne', 'toujours pendant la panne', 'après']));
+    });
+    it('relit le spool au tick qui suit la fin du recul, sans nouveau log', async () => {
+        useFakeClock();
+        sendBulk.mockRejectedValueOnce(httpError(503));
+        const shipper = shipperOn({ flushIntervalMs: 500 });
+        shipper.enqueue(makeLog('pendant la panne'));
+        await shipper.flush();
+        expect(spooledFiles(base)).toHaveLength(1);
+        await jest.advanceTimersByTimeAsync(log_shipper_model_1.BACKOFF_BASE_MS + 500);
+        await settle();
+        expect(spooledFiles(base)).toHaveLength(0);
+        expect(sendBulk).toHaveBeenCalledTimes(2);
+        expect(messagesOf(1)).toEqual(['pendant la panne']);
+    });
+    it('rejoue un lot avec sa date d émission et son clientLogId d origine', async () => {
+        const emittedAt = new Date('2026-09-10T08:00:00.000Z');
+        const log = makeLog('a', emittedAt);
+        sendBulk.mockRejectedValueOnce(httpError(503));
+        const first = shipperOn();
+        first.enqueue(log);
+        await first.flush();
+        first.stop();
+        const second = shipperOn();
+        const replayed = await second.replaySpool();
+        expect(replayed).toBe(1);
+        const resent = sendBulk.mock.calls[1][2].logs[0];
+        expect(new Date(resent.dateValue).toISOString()).toBe(emittedAt.toISOString());
+        expect(resent.clientLogId).toBe(log.clientLogId);
+    });
+    it("ne rejoue jamais le spool d'une autre application", async () => {
+        sendBulk.mockRejectedValueOnce(httpError(503));
+        const first = shipperOn();
+        first.enqueue(makeLog('à app-1'));
+        await first.flush();
+        first.stop();
+        __1.AbyssMonitorCore.setConfig({ applicationId: 'app-2', secretPublishToken: 'other' });
+        const second = shipperOn();
+        const replayed = await second.replaySpool();
+        expect(replayed).toBe(0);
+        expect(sendBulk).toHaveBeenCalledTimes(1);
+    });
+    it('sans spool, remet le lot en tête de file sur un échec transitoire', async () => {
+        useFakeClock();
+        sendBulk.mockRejectedValueOnce(httpError(503));
+        const shipper = shipperOn({ spoolDirectory: null });
+        shipper.enqueue(makeLog('a'));
+        await shipper.flush();
+        shipper.enqueue(makeLog('b'));
+        jest.setSystemTime(Date.now() + log_shipper_model_1.BACKOFF_BASE_MS + 1);
+        await shipper.flush();
+        expect(sendBulk).toHaveBeenCalledTimes(2);
+        expect(messagesOf(1)).toEqual(['a', 'b']);
+        expect(fs.existsSync(path.join(base, APPLICATION_ID))).toBe(false);
+    });
+    it('un flush de sortie envoie malgré un recul en cours', async () => {
+        sendBulk.mockRejectedValueOnce(httpError(503));
+        const shipper = shipperOn();
+        shipper.enqueue(makeLog('avant'));
+        await shipper.flush();
+        shipper.enqueue(makeLog('à la sortie'));
+        await shipper.flush(3_000, { ignoreBackoff: true });
+        await settle();
+        expect(messagesOf(1)).toEqual(['à la sortie']);
+        expect(allShipped()).toEqual(['avant', 'à la sortie', 'avant']);
+    });
+    it('à la sortie, après un échec, le reste descend sur disque sans nouvel envoi', async () => {
+        useFakeClock();
+        sendBulk.mockRejectedValueOnce(httpError(503));
+        const shipper = shipperOn({ maxBatchEntries: 1 });
+        shipper.enqueue(makeLog('a'));
+        shipper.enqueue(makeLog('b'));
+        shipper.enqueue(makeLog('c'));
+        await shipper.flush(3_000, { ignoreBackoff: true });
+        expect(sendBulk).toHaveBeenCalledTimes(1);
+        expect(spooledFiles(base)).toHaveLength(3);
+    });
+    it('flush ne lève jamais, même si le transport échoue', async () => {
+        sendBulk.mockRejectedValue(new Error('monitor down'));
+        const shipper = shipperOn();
+        shipper.enqueue(makeLog('a'));
+        await expect(shipper.flush()).resolves.toBeUndefined();
+    });
+    it('replaySpool ne rejette jamais', async () => {
+        jest.spyOn(log_spool_model_1.LogSpool.prototype, 'listPendingBatches').mockRejectedValueOnce(new Error('disk'));
+        const shipper = shipperOn();
+        await expect(shipper.replaySpool()).resolves.toBe(0);
+    });
+    it('classe les refus', () => {
+        expect((0, log_shipper_model_1.classifySendError)(httpError(400))).toBe(log_shipper_model_1.SendOutcome.DROP);
+        expect((0, log_shipper_model_1.classifySendError)(httpError(413))).toBe(log_shipper_model_1.SendOutcome.DROP);
+        expect((0, log_shipper_model_1.classifySendError)(httpError(422))).toBe(log_shipper_model_1.SendOutcome.DROP);
+        expect((0, log_shipper_model_1.classifySendError)(httpError(404))).toBe(log_shipper_model_1.SendOutcome.RETRY);
+        expect((0, log_shipper_model_1.classifySendError)(Object.assign(new Error('timeout of 10000ms exceeded'), { code: 'ECONNABORTED' }))).toBe(log_shipper_model_1.SendOutcome.RETRY);
+        expect((0, log_shipper_model_1.classifySendError)(httpError(500))).toBe(log_shipper_model_1.SendOutcome.RETRY);
+        expect((0, log_shipper_model_1.classifySendError)(httpError(503))).toBe(log_shipper_model_1.SendOutcome.RETRY);
+        expect((0, log_shipper_model_1.classifySendError)(httpError(429))).toBe(log_shipper_model_1.SendOutcome.RETRY);
+        expect((0, log_shipper_model_1.classifySendError)(httpError(401))).toBe(log_shipper_model_1.SendOutcome.RETRY);
+        expect((0, log_shipper_model_1.classifySendError)(httpError(403))).toBe(log_shipper_model_1.SendOutcome.RETRY);
+        expect((0, log_shipper_model_1.classifySendError)(new Error('ECONNREFUSED'))).toBe(log_shipper_model_1.SendOutcome.RETRY);
+        expect((0, log_shipper_model_1.classifySendError)(null)).toBe(log_shipper_model_1.SendOutcome.RETRY);
+        expect((0, log_shipper_model_1.classifySendError)('down')).toBe(log_shipper_model_1.SendOutcome.RETRY);
+    });
+    it('prend le répertoire du spool dans ABYSS_MONITOR_SPOOL_DIR, sinon dans le répertoire temporaire', () => {
+        try {
+            process.env[log_shipper_model_1.SPOOL_DIRECTORY_ENV] = '/var/spool/abyss';
+            expect((0, log_shipper_model_1.resolveSpoolBase)()).toBe('/var/spool/abyss');
+            expect((0, log_shipper_model_1.resolveSpoolBase)('/explicit')).toBe('/explicit');
+            delete process.env[log_shipper_model_1.SPOOL_DIRECTORY_ENV];
+            expect((0, log_shipper_model_1.resolveSpoolBase)()).toBe(path.join(os.tmpdir(), 'abyss-monitor-spool'));
+        }
+        finally {
+            if (ORIGINAL_SPOOL_DIRECTORY_ENV === undefined) {
+                delete process.env[log_shipper_model_1.SPOOL_DIRECTORY_ENV];
+            }
+            else {
+                process.env[log_shipper_model_1.SPOOL_DIRECTORY_ENV] = ORIGINAL_SPOOL_DIRECTORY_ENV;
+            }
+        }
+    });
+    it('restaure le sandbox de spool après le test précédent, au lieu de le laisser supprimé', () => {
+        expect(ORIGINAL_SPOOL_DIRECTORY_ENV).toEqual(expect.any(String));
+        expect(process.env[log_shipper_model_1.SPOOL_DIRECTORY_ENV]).toBe(ORIGINAL_SPOOL_DIRECTORY_ENV);
+    });
+    it('hors Node : ni spool ni exception', async () => {
+        const globals = globalThis;
+        const originalBuffer = globals.Buffer;
+        globals.window = {};
+        try {
+            expect((0, log_shipper_model_1.resolveSpoolBase)('/explicit')).toBeNull();
+            const shipper = shipperOn();
+            globals.Buffer = undefined;
+            try {
+                shipper.enqueue(makeLog('navigateur'));
+            }
+            finally {
+                globals.Buffer = originalBuffer;
+            }
+            await shipper.flush();
+            expect(messagesOf(0)).toEqual(['navigateur']);
+            expect(fs.existsSync(path.join(base, APPLICATION_ID))).toBe(false);
+        }
+        finally {
+            delete globals.window;
+        }
+    });
+    it('prévient une seule fois quand le spool est inutilisable', async () => {
+        const blocker = path.join(base, 'not-a-directory');
+        fs.writeFileSync(blocker, '');
+        const warn = jest.spyOn(console, 'warn').mockImplementation(() => undefined);
+        const shipper = shipperOn({ spoolDirectory: blocker });
+        shipper.enqueue(makeLog('a'));
+        await shipper.flush();
+        shipper.enqueue(makeLog('b'));
+        await shipper.flush();
+        expect(warn).toHaveBeenCalledTimes(1);
+        expect(warn.mock.calls[0][0]).toContain(log_shipper_model_1.SPOOL_DIRECTORY_ENV);
+        expect(sendBulk).toHaveBeenCalledTimes(2);
+    });
+    it('enqueue ne fait aucune E/S : un lot plein part au tour suivant de la boucle', async () => {
+        useFakeClock();
+        const shipper = shipperOn({ maxBatchEntries: 2 });
+        shipper.enqueue(makeLog('a'));
+        shipper.enqueue(makeLog('b'));
+        shipper.enqueue(makeLog('c'));
+        expect(fs.existsSync(path.join(base, APPLICATION_ID))).toBe(false);
+        expect(sendBulk).not.toHaveBeenCalled();
+        expect(jest.getTimerCount()).toBe(2);
+        await jest.advanceTimersByTimeAsync(0);
+        await settle();
+        expect(allShipped()).toEqual(['a', 'b', 'c']);
+        expect(spooledFiles(base)).toHaveLength(0);
+    });
+    it("prend la taille déjà mesurée par l'appelant, sans resérialiser la ligne", async () => {
+        const shipper = shipperOn({ maxQueueBytes: 1_000 });
+        const stringify = jest.spyOn(JSON, 'stringify');
+        shipper.enqueue(makeLog('a'), 600);
+        shipper.enqueue(makeLog('b'), 600);
+        expect(stringify).not.toHaveBeenCalled();
+        stringify.mockRestore();
+        await shipper.flush();
+        expect(allShipped()).toEqual(['b']);
+        expect(sendBulk.mock.calls[0][2].droppedCount).toBe(1);
+    });
+    it('un log impossible à sérialiser ne fait pas lever enqueue, et il est compté', async () => {
+        const shipper = shipperOn();
+        const data = {};
+        data.self = data;
+        const circular = { ...makeLog('circulaire'), data };
+        expect(() => shipper.enqueue(circular)).not.toThrow();
+        shipper.enqueue(makeLog('ok'));
+        await shipper.flush();
+        expect(messagesOf(0)).toEqual(['ok']);
+        expect(sendBulk.mock.calls[0][2].droppedCount).toBe(1);
+    });
+    it("un envoi qui échoue transitoirement ne perd pas le décompte qu'il portait", async () => {
+        sendBulk.mockRejectedValueOnce(httpError(503));
+        const shipper = shipperOn({ maxQueueEntries: 1 });
+        shipper.enqueue(makeLog('a'));
+        shipper.enqueue(makeLog('b'));
+        await shipper.flush();
+        expect(sendBulk.mock.calls[0][2].droppedCount).toBe(1);
+        shipper.enqueue(makeLog('c'));
+        await shipper.flush(3_000, { ignoreBackoff: true });
+        expect(messagesOf(1)).toEqual(['c']);
+        expect(sendBulk.mock.calls[1][2].droppedCount).toBe(1);
+    });
+    it("un lot refusé définitivement rend le décompte qu'il portait, en plus de ses lignes", async () => {
+        sendBulk.mockRejectedValueOnce(httpError(422));
+        const shipper = shipperOn({ maxQueueEntries: 1 });
+        shipper.enqueue(makeLog('a'));
+        shipper.enqueue(makeLog('b'));
+        await shipper.flush();
+        shipper.enqueue(makeLog('c'));
+        await shipper.flush();
+        expect(sendBulk.mock.calls[1][2].droppedCount).toBe(2);
+    });
+    it('remonte les lignes évincées du spool plein', async () => {
+        sendBulk.mockRejectedValueOnce(httpError(503)).mockRejectedValueOnce(httpError(503));
+        const shipper = shipperOn({ spoolMaxBytes: 500 });
+        shipper.enqueue(makeLog('a'.repeat(200)));
+        await shipper.flush();
+        shipper.enqueue(makeLog('b'.repeat(200)));
+        await shipper.flush(3_000, { ignoreBackoff: true });
+        expect(spooledFiles(base)).toHaveLength(1);
+        shipper.enqueue(makeLog('c'));
+        await shipper.flush(3_000, { ignoreBackoff: true });
+        expect(sendBulk.mock.calls[1][2].droppedCount).toBe(1);
+        expect(messagesOf(2)).toEqual(['c']);
+        expect(sendBulk.mock.calls[2][2].droppedCount).toBe(1);
+    });
+    it('un lot illisible sur disque est écarté et compté', async () => {
+        sendBulk.mockRejectedValueOnce(httpError(503));
+        const first = shipperOn();
+        first.enqueue(makeLog('a'));
+        first.enqueue(makeLog('b'));
+        await first.flush();
+        first.stop();
+        const [file] = spooledFiles(base);
+        fs.writeFileSync(path.join(base, APPLICATION_ID, file), '{"message":"tronq');
+        const second = shipperOn();
+        expect(await second.replaySpool()).toBe(0);
+        expect(spooledFiles(base)).toHaveLength(0);
+        second.enqueue(makeLog('c'));
+        await second.flush();
+        expect(sendBulk.mock.calls[1][2].droppedCount).toBe(2);
+    });
+    it("un lot livré entre le listage et la lecture du rejeu n'est pas compté comme perdu", async () => {
+        useFakeClock();
+        sendBulk.mockRejectedValueOnce(httpError(503));
+        const shipper = shipperOn();
+        shipper.enqueue(makeLog('g'));
+        await shipper.flush();
+        jest.setSystemTime(Date.now() + log_shipper_model_1.BACKOFF_BASE_MS + 1);
+        const fSend = deferred();
+        sendBulk.mockReturnValueOnce(fSend.promise);
+        shipper.enqueue(makeLog('f'));
+        const flushing = shipper.flush();
+        await settle();
+        const gSend = deferred();
+        sendBulk.mockReturnValueOnce(gSend.promise);
+        const replay = shipper.replaySpool();
+        await settle();
+        expect(allShipped()).toEqual(['g', 'f', 'g']);
+        fSend.resolve(ACK);
+        await flushing;
+        gSend.resolve(ACK);
+        expect(await replay).toBe(1);
+        shipper.enqueue(makeLog('h'));
+        await shipper.flush();
+        expect(messagesOf(3)).toEqual(['h']);
+        expect(sendBulk.mock.calls[3][2].droppedCount).toBeNull();
+    });
+    it("pendant le recul, un lot que le spool refuse d'écrire reste en mémoire", async () => {
+        useFakeClock();
+        sendBulk.mockRejectedValueOnce(httpError(503));
+        const shipper = shipperOn();
+        shipper.enqueue(makeLog('a'));
+        await shipper.flush();
+        const writeBatch = jest.spyOn(log_spool_model_1.LogSpool.prototype, 'writeBatch').mockResolvedValueOnce(null);
+        shipper.enqueue(makeLog('b'));
+        await shipper.flush();
+        expect(writeBatch).toHaveBeenCalledTimes(1);
+        expect(sendBulk).toHaveBeenCalledTimes(1);
+        jest.setSystemTime(Date.now() + log_shipper_model_1.BACKOFF_BASE_MS + 1);
+        await shipper.flush();
+        await settle();
+        expect(messagesOf(1)).toEqual(['b']);
+        expect(sendBulk.mock.calls[1][2].droppedCount).toBeNull();
+        expect(allShipped()).toEqual(['a', 'b', 'a']);
+    });
+    it("le premier tick d'un shipper neuf ne POSTe son lot qu'une fois", async () => {
+        useFakeClock();
+        const shipper = shipperOn({ flushIntervalMs: 500 });
+        shipper.enqueue(makeLog('first'));
+        await jest.advanceTimersByTimeAsync(500);
+        await settle();
+        expect(allShipped()).toEqual(['first']);
+        expect(spooledFiles(base)).toHaveLength(0);
+    });
+    it("au premier tick, une ligne refusée n'est découpée et comptée qu'une fois", async () => {
+        useFakeClock();
+        sendBulk.mockImplementation(refusingMarked(400));
+        const shipper = shipperOn({ flushIntervalMs: 500 });
+        shipper.enqueue(makeLog('a'));
+        shipper.enqueue(makeLog(`bad ${REFUSED}`));
+        await jest.advanceTimersByTimeAsync(500);
+        await settle();
+        shipper.enqueue(makeLog('next'));
+        await shipper.flush();
+        expect(sendBulk.mock.calls.map((call) => call[2].logs.length)).toEqual([2, 1, 1, 1]);
+        expect(accepted.map((body) => body.droppedCount)).toEqual([null, 1]);
+    });
+    it('un flush suivi d un rejeu dans le même tour ne POSTe pas le lot deux fois', async () => {
+        const shipper = shipperOn();
+        shipper.enqueue(makeLog('first'));
+        const flushing = shipper.flush();
+        const replaying = shipper.replaySpool();
+        await Promise.all([flushing, replaying]);
+        await settle();
+        expect(allShipped()).toEqual(['first']);
+    });
+    it('à la sortie, un flush en vol bloqué ne retarde pas le déversement au-delà du délai', async () => {
+        useFakeClock();
+        const hung = deferred();
+        sendBulk.mockReturnValueOnce(hung.promise);
+        const shipper = shipperOn();
+        shipper.enqueue(makeLog('a'));
+        const regular = shipper.flush();
+        await settle();
+        shipper.enqueue(makeLog('b'));
+        let exited = false;
+        const exit = shipper.flush(100, { ignoreBackoff: true }).then(() => {
+            exited = true;
+        });
+        await jest.advanceTimersByTimeAsync(100);
+        await settle();
+        expect(exited).toBe(true);
+        expect(spooledFiles(base)).toHaveLength(2);
+        expect(sendBulk).toHaveBeenCalledTimes(1);
+        hung.resolve(ACK);
+        await Promise.all([regular, exit]);
+    });
+    it('à la sortie, un flush en vol qui finit à temps laisse le reste partir par le réseau', async () => {
+        useFakeClock();
+        const slow = deferred();
+        sendBulk.mockReturnValueOnce(slow.promise);
+        const shipper = shipperOn();
+        shipper.enqueue(makeLog('a'));
+        const regular = shipper.flush();
+        await settle();
+        shipper.enqueue(makeLog('b'));
+        const exit = shipper.flush(1_000, { ignoreBackoff: true });
+        await jest.advanceTimersByTimeAsync(50);
+        slow.resolve(ACK);
+        await Promise.all([regular, exit]);
+        expect(allShipped()).toEqual(['a', 'b']);
+        expect(spooledFiles(base)).toHaveLength(0);
+        expect(jest.getTimerCount()).toBe(1);
+    });
+    it("à la sortie sans identité, le déversement n'a nulle part où écrire et ne lève rien", async () => {
+        useFakeClock();
+        const hung = deferred();
+        sendBulk.mockReturnValueOnce(hung.promise);
+        const shipper = shipperOn();
+        shipper.enqueue(makeLog('a'));
+        const regular = shipper.flush();
+        await settle();
+        shipper.enqueue(makeLog('b'));
+        __1.AbyssMonitorCore.setConfig({ applicationId: '' });
+        const exit = shipper.flush(100, { ignoreBackoff: true });
+        await jest.advanceTimersByTimeAsync(100);
+        await exit;
+        expect(console.error).not.toHaveBeenCalled();
+        hung.resolve(ACK);
+        await regular;
+        __1.AbyssMonitorCore.setConfig({ applicationId: APPLICATION_ID });
+        await shipper.flush();
+        expect(allShipped()).toEqual(['a', 'b']);
+    });
+    it('un fichier momentanément illisible est gardé, puis livré au rejeu suivant', async () => {
+        useFakeClock();
+        sendBulk.mockRejectedValueOnce(httpError(503));
+        const first = shipperOn();
+        first.enqueue(makeLog('a'));
+        await first.flush();
+        first.stop();
+        const realFs = jest.requireActual('fs');
+        jest.spyOn(realFs, 'readFileSync').mockImplementationOnce(() => {
+            throw Object.assign(new Error('EBUSY: resource busy or locked'), { code: 'EBUSY' });
+        });
+        const second = shipperOn({ flushIntervalMs: 500 });
+        expect(await second.replaySpool()).toBe(0);
+        expect(spooledFiles(base)).toHaveLength(1);
+        expect(sendBulk).toHaveBeenCalledTimes(1);
+        await jest.advanceTimersByTimeAsync(500);
+        await settle();
+        expect(spooledFiles(base)).toHaveLength(0);
+        expect(messagesOf(1)).toEqual(['a']);
+        expect(sendBulk.mock.calls[1][2].droppedCount).toBeNull();
+    });
+    it('un fichier illisible en tête ne retient pas les suivants dans le même rejeu', async () => {
+        const previous = new log_spool_model_1.LogSpool({
+            directory: path.join(base, APPLICATION_ID),
+            maxBytes: 1_000_000,
+        });
+        const head = await previous.writeBatch([makeLog('tête')]);
+        await previous.writeBatch([makeLog('suivant')]);
+        const realFs = jest.requireActual('fs');
+        jest.spyOn(realFs, 'readFileSync').mockImplementationOnce(() => {
+            throw Object.assign(new Error('EBUSY: resource busy or locked'), { code: 'EBUSY' });
+        });
+        const shipper = shipperOn();
+        expect(await shipper.replaySpool()).toBe(1);
+        expect(allShipped()).toEqual(['suivant']);
+        expect(spooledFiles(base)).toEqual([head.fileName]);
+        expect(shipper.mayHavePendingSpool()).toBe(true);
+    });
+    it("ne rejoue pas le fichier temporaire d'un lot encore en cours d'écriture", async () => {
+        const directory = path.join(base, APPLICATION_ID);
+        fs.mkdirSync(directory, { recursive: true });
+        const temporary = path.join(directory, '.tmp-batch-1-99999-000001-n1.jsonl');
+        fs.writeFileSync(temporary, JSON.stringify(makeLog('à moitié écrit')));
+        const shipper = shipperOn();
+        expect(await shipper.replaySpool()).toBe(0);
+        expect(sendBulk).not.toHaveBeenCalled();
+        expect(fs.existsSync(temporary)).toBe(true);
+    });
+    it("ne rejoue pas un lot en cours d'envoi", async () => {
+        const pending = deferred();
+        sendBulk.mockReturnValueOnce(pending.promise);
+        const shipper = shipperOn();
+        shipper.enqueue(makeLog('en vol'));
+        const flushing = shipper.flush();
+        await settle();
+        expect(sendBulk).toHaveBeenCalledTimes(1);
+        expect(spooledFiles(base)).toHaveLength(1);
+        expect(await shipper.replaySpool()).toBe(0);
+        expect(sendBulk).toHaveBeenCalledTimes(1);
+        pending.resolve(ACK);
+        await flushing;
+        expect(spooledFiles(base)).toHaveLength(0);
+    });
+    it('un lot laissé sur disque pendant un rejeu est relu ensuite', async () => {
+        useFakeClock();
+        sendBulk.mockRejectedValueOnce(httpError(503));
+        const shipper = shipperOn({ flushIntervalMs: 500 });
+        shipper.enqueue(makeLog('ancien'));
+        await shipper.flush();
+        jest.setSystemTime(Date.now() + log_shipper_model_1.BACKOFF_BASE_MS + 1);
+        const replayedSend = deferred();
+        sendBulk.mockReturnValueOnce(replayedSend.promise);
+        const replay = shipper.replaySpool();
+        await settle();
+        sendBulk.mockRejectedValueOnce(httpError(503));
+        shipper.enqueue(makeLog('nouveau'));
+        await shipper.flush();
+        replayedSend.resolve(ACK);
+        expect(await replay).toBe(1);
+        expect(spooledFiles(base)).toHaveLength(1);
+        await jest.advanceTimersByTimeAsync(500);
+        await settle();
+        expect(spooledFiles(base)).toHaveLength(0);
+        expect(allShipped()).toEqual(['ancien', 'ancien', 'nouveau', 'nouveau']);
+    });
+    it('des flush concurrents ne font jamais deux envois à la fois', async () => {
+        useFakeClock();
+        let outstanding = 0;
+        let maxOutstanding = 0;
+        const releases = [];
+        sendBulk.mockImplementation(() => {
+            outstanding += 1;
+            maxOutstanding = Math.max(maxOutstanding, outstanding);
+            return new Promise((resolve) => releases.push(() => {
+                outstanding -= 1;
+                jest.setSystemTime(Date.now() + 10);
+                resolve(ACK);
+            }));
+        });
+        const shipper = shipperOn({ spoolDirectory: null, maxBatchEntries: 1 });
+        shipper.enqueue(makeLog('a'));
+        const first = shipper.flush(5);
+        await settle();
+        shipper.enqueue(makeLog('b'));
+        shipper.enqueue(makeLog('c'));
+        const second = shipper.flush();
+        const third = shipper.flush();
+        for (let turn = 0; turn < 10 && releases.length > 0; turn += 1) {
+            releases.shift()?.();
+            await settle();
+        }
+        await Promise.all([first, second, third]);
+        expect(allShipped()).toEqual(['a', 'b', 'c']);
+        expect(maxOutstanding).toBe(1);
+    });
+    it("le délai d'un flush court depuis son appel, attente comprise", async () => {
+        useFakeClock();
+        const hung = deferred();
+        sendBulk.mockReturnValueOnce(hung.promise);
+        const shipper = shipperOn({ spoolDirectory: null });
+        shipper.enqueue(makeLog('a'));
+        const first = shipper.flush(500);
+        await settle();
+        shipper.enqueue(makeLog('b'));
+        const second = shipper.flush(1_000);
+        jest.setSystemTime(Date.now() + 2_000);
+        hung.resolve(ACK);
+        await Promise.all([first, second]);
+        expect(sendBulk).toHaveBeenCalledTimes(1);
+    });
+    it('reconfigure garde la file et applique la nouvelle taille de lot', async () => {
+        const shipper = shipperOn();
+        ['a', 'b', 'c'].forEach((message) => shipper.enqueue(makeLog(message)));
+        shipper.reconfigure({ spoolDirectory: base, flushIntervalMs: 60_000, maxBatchEntries: 1 });
+        await shipper.flush();
+        expect(sendBulk.mock.calls.map((call) => call[2].logs.length)).toEqual([1, 1, 1]);
+        expect(allShipped()).toEqual(['a', 'b', 'c']);
+    });
+    it("reconfigure vers un autre répertoire de spool y écrit, et rejoue ce qu'il y trouve", async () => {
+        const other = fs.mkdtempSync(path.join(os.tmpdir(), 'abyss-shipper-other-'));
+        try {
+            await new log_spool_model_1.LogSpool({
+                directory: path.join(other, APPLICATION_ID),
+                maxBytes: 1_000_000,
+            }).writeBatch([makeLog('laissé là')]);
+            const shipper = shipperOn();
+            expect(await shipper.replaySpool()).toBe(0);
+            expect(shipper.mayHavePendingSpool()).toBe(false);
+            shipper.reconfigure({ spoolDirectory: other, flushIntervalMs: 60_000 });
+            expect(shipper.mayHavePendingSpool()).toBe(true);
+            expect(await shipper.replaySpool()).toBe(1);
+            expect(allShipped()).toEqual(['laissé là']);
+            sendBulk.mockRejectedValueOnce(httpError(503));
+            shipper.enqueue(makeLog('après'));
+            await shipper.flush();
+            expect(spooledFiles(other)).toHaveLength(1);
+            expect(spooledFiles(base)).toHaveLength(0);
+        }
+        finally {
+            fs.rmSync(other, { recursive: true, force: true });
+        }
+    });
+    it('reconfigure réarme le flush périodique sur le nouvel intervalle', async () => {
+        useFakeClock();
+        const shipper = shipperOn();
+        shipper.enqueue(makeLog('a'));
+        shipper.reconfigure({ spoolDirectory: base, flushIntervalMs: 100 });
+        await jest.advanceTimersByTimeAsync(100);
+        await settle();
+        expect(allShipped()).toEqual(['a']);
+        expect(jest.getTimerCount()).toBe(1);
+    });
+    it('un shipper arrêté reste arrêté quand on le reconfigure', async () => {
+        useFakeClock();
+        const shipper = shipperOn();
+        shipper.enqueue(makeLog('a'));
+        shipper.stop();
+        shipper.reconfigure({ spoolDirectory: base, flushIntervalMs: 100 });
+        await jest.advanceTimersByTimeAsync(1_000);
+        await settle();
+        expect(sendBulk).not.toHaveBeenCalled();
+        expect(jest.getTimerCount()).toBe(0);
+    });
+    it('reconfigure applique tout de suite des plafonds de file plus serrés, en comptant', async () => {
+        const shipper = shipperOn();
+        ['a', 'b', 'c'].forEach((message) => shipper.enqueue(makeLog(message)));
+        shipper.reconfigure({ spoolDirectory: base, flushIntervalMs: 60_000, maxQueueEntries: 1 });
+        await shipper.flush();
+        expect(allShipped()).toEqual(['c']);
+        expect(sendBulk.mock.calls[0][2].droppedCount).toBe(2);
+    });
+    it("les évictions d'un spool abandonné par reconfigure sont quand même remontées", async () => {
+        useFakeClock();
+        sendBulk.mockRejectedValueOnce(httpError(503));
+        const shipper = shipperOn({ spoolMaxBytes: 500 });
+        shipper.enqueue(makeLog('a'.repeat(200)));
+        await shipper.flush();
+        shipper.enqueue(makeLog('b'.repeat(200)));
+        await shipper.flush();
+        expect(sendBulk).toHaveBeenCalledTimes(1);
+        expect(spooledFiles(base)).toHaveLength(1);
+        shipper.reconfigure({ spoolDirectory: null, flushIntervalMs: 60_000 });
+        jest.setSystemTime(Date.now() + log_shipper_model_1.BACKOFF_BASE_MS + 1);
+        shipper.enqueue(makeLog('c'));
+        await shipper.flush();
+        expect(messagesOf(1)).toEqual(['c']);
+        expect(sendBulk.mock.calls[1][2].droppedCount).toBe(1);
+    });
+    it('à la sortie, le délai écoulé, ce qui reste en file descend sur disque sans POST', async () => {
+        useFakeClock();
+        const shipper = shipperOn({ maxBatchEntries: 2 });
+        ['a', 'b', 'c', 'd', 'e'].forEach((message) => shipper.enqueue(makeLog(message)));
+        await shipper.flush(0, { ignoreBackoff: true });
+        expect(sendBulk).not.toHaveBeenCalled();
+        const spooled = spooledFiles(base)
+            .sort()
+            .flatMap((file) => fs
+            .readFileSync(path.join(base, APPLICATION_ID, file), 'utf8')
+            .split('\n')
+            .map((line) => JSON.parse(line).message));
+        expect(spooled).toEqual(['a', 'b', 'c', 'd', 'e']);
+    });
+    it('à la sortie, un POST qui ne répond jamais finit dans le délai, et toute la file est sur disque', async () => {
+        useFakeClock();
+        sendBulk.mockImplementation((_params, _query, _body, options) => new Promise((_resolve, reject) => {
+            setTimeout(() => reject(Object.assign(new Error('timeout exceeded'), { code: 'ECONNABORTED' })), options?.timeoutMs ?? applicationLogApi.BULK_REQUEST_TIMEOUT_MS);
+        }));
+        const shipper = shipperOn();
+        const emitted = Array.from({ length: 250 }, (_, index) => `line-${index}`);
+        emitted.forEach((message) => shipper.enqueue(makeLog(message)));
+        const deadlineMs = 300;
+        const exit = Promise.race([
+            shipper.flush(deadlineMs, { ignoreBackoff: true }),
+            new Promise((resolve) => setTimeout(resolve, deadlineMs + 250)),
+        ]);
+        await jest.advanceTimersByTimeAsync(deadlineMs + 250);
+        await exit;
+        expect(sendBulk).toHaveBeenCalledTimes(1);
+        expect(sendBulk.mock.calls[0][3]).toEqual({ timeoutMs: deadlineMs });
+        const onDisk = spooledFiles(base).flatMap((file) => fs
+            .readFileSync(path.join(base, APPLICATION_ID, file), 'utf8')
+            .split('\n')
+            .map((line) => JSON.parse(line).message));
+        expect(onDisk.sort()).toEqual([...emitted].sort());
+    });
+    it('un flush ordinaire garde le délai de requête par défaut', async () => {
+        const shipper = shipperOn();
+        shipper.enqueue(makeLog('a'));
+        await shipper.flush();
+        expect(sendBulk.mock.calls[0][3]).toEqual({ timeoutMs: undefined });
+    });
+    it('à la sortie sans spool, ce que le délai laisse en file est perdu et compté', async () => {
+        useFakeClock();
+        const shipper = shipperOn({ spoolDirectory: null });
+        ['a', 'b', 'c'].forEach((message) => shipper.enqueue(makeLog(message)));
+        await shipper.flush(0, { ignoreBackoff: true });
+        expect(sendBulk).not.toHaveBeenCalled();
+        shipper.enqueue(makeLog('x'));
+        await shipper.flush();
+        expect(messagesOf(0)).toEqual(['x']);
+        expect(sendBulk.mock.calls[0][2].droppedCount).toBe(3);
+    });
+    it("à la sortie sans spool, un échec fait compter ce qui reste au lieu de l'abandonner en file", async () => {
+        useFakeClock();
+        sendBulk.mockRejectedValueOnce(httpError(503));
+        const shipper = shipperOn({ spoolDirectory: null, maxBatchEntries: 1 });
+        shipper.enqueue(makeLog('a'));
+        shipper.enqueue(makeLog('b'));
+        await shipper.flush(3_000, { ignoreBackoff: true });
+        expect(sendBulk).toHaveBeenCalledTimes(1);
+        shipper.enqueue(makeLog('x'));
+        await shipper.flush(3_000, { ignoreBackoff: true });
+        expect(messagesOf(1)).toEqual(['x']);
+        expect(sendBulk.mock.calls[1][2].droppedCount).toBe(2);
+    });
+    it("un envoi bloqué n'empile pas un flush par tick", async () => {
+        useFakeClock();
+        const hung = deferred();
+        sendBulk.mockReturnValueOnce(hung.promise);
+        const drainAll = jest.spyOn(log_shipper_model_1.LogShipper.prototype, 'drainAll');
+        const shipper = shipperOn({ flushIntervalMs: 500 });
+        shipper.enqueue(makeLog('a'));
+        const flushing = shipper.flush();
+        await settle();
+        await jest.advanceTimersByTimeAsync(5_000);
+        hung.resolve(ACK);
+        await flushing;
+        await settle();
+        expect(drainAll).toHaveBeenCalledTimes(1);
+    });
+});
+//# sourceMappingURL=log-shipper.test.js.map