Fatal: Check failed: (location_) != nullptr. in node v24.11.1

[Jayx239]

Version

v24.11.1

Platform

Linux <redacted_host_name> 6.14.0-35-generic #35~24.04.1-Ubuntu SMP PREEMPT_DYNAMIC Tue Oct 14 13:55:17 UTC 2 x86_64 x86_64 x86_64 GNU/Linux

Subsystem

No response

What steps will reproduce the bug?

npm run test:integ

package.json:

{
...
"scripts": {
...
    "test:integ": "node --test --test-concurrency=1 ./integ/*integ.ts"
}
...

Output:

#
# Fatal error in , line 0
# Check failed: (location_) != nullptr.
#
#
#
#FailureMessage Object: 0x7c5452bf45f0
----- Native stack trace -----

 1: 0x942cf1  [/home/jmoney/.nvm/versions/node/v24.11.1/bin/node]
 2: 0x2684403 V8_Fatal(char const*, ...) [/home/jmoney/.nvm/versions/node/v24.11.1/bin/node]
 3: 0x119e9b3  [/home/jmoney/.nvm/versions/node/v24.11.1/bin/node]
 4: 0xc0a160  [/home/jmoney/.nvm/versions/node/v24.11.1/bin/node]
 5: 0x7c5353e76576 

How often does it reproduce? Is there a required condition?

I have seen this before while testing pre-release 24 versions, but am seeing this consistently while running node --test. The behavior is oncisistent, where sometimes this occurs 1 out of 6 tests, and other times 3 out of 6 tests fail. I have not debugged too deep, so I am not really sure what conditions are causing this.

That being said, one of my hunches is that this has to do with a bug in thread workers or the exec/spawn process functionality. I have created a library that wraps thread workers and process methods to provide a facade for parralel execution, so I think that this may be a result of failures in some of the system calls. Regardless, I don't think that nodejs users should be able to trigger unhandled faults in the nodejs runtime like this.

What is the expected behavior? Why is that the expected behavior?

The expected behavior is that node js does not have internal failures from application layer runtime behavior.

What do you see instead?

#
# Fatal error in , line 0
# Check failed: (location_) != nullptr.
#
#
#
#FailureMessage Object: 0x7c5452bf45f0
----- Native stack trace -----

 1: 0x942cf1  [/home/<userName>/.nvm/versions/node/v24.11.1/bin/node]
 2: 0x2684403 V8_Fatal(char const*, ...) [/home/<userName>/.nvm/versions/node/v24.11.1/bin/node]
 3: 0x119e9b3  [/home/<userName>/.nvm/versions/node/v24.11.1/bin/node]
 4: 0xc0a160  [/home/<userName>/.nvm/versions/node/v24.11.1/bin/node]
 5: 0x7c5353e76576 

Additional information

The nature of the library I am testing performs a lot of file system operations, as well as some parralel execution mostly with thread workers if this can help narrow down the scope. It is a private library right now so the code is not publically accessible for review, but I can provide examples or code snippets as necessary to debug.

dependencies

  "dependencies": {
    "<myFork>/express": "^4.19.2",
    "@swizzyweb/oauth-middleware": "^0.1.1",
    "@swizzyweb/quirk": "^0.1.3", // Unreleased parralel computing library
... (other first party dependencies of mine)
    "jsonpath-plus": "^10.3.0",
    "typescript": "^5.9.3"
  },
  "devDependencies": {
    "@swizzyweb/swerve": "^0.5.8",
    "@types/jest": "^30.0.0",
    "@types/jsonpath-plus": "^5.0.5",
    "@types/node": "^22.18.8",
    "@types/supertest": "^6.0.3",
    "jest": "^30.2.0",
    "supertest": "^7.1.4",
    "ts-jest": "^29.4.4",
    "ts-node-dev": "^2.0.0"
  }

[Jayx239]

Received this other error message too:

#
# Fatal error in , line 0
# Check failed: (location_) != nullptr.
#
#
#
#FailureMessage Object: 0x73bc5ebf55f0
----- Native stack trace -----

 1: 0x942cf1  [/home/<userName>/.nvm/versions/node/v24.11.1/bin/node]
 2: 0x2684403 V8_Fatal(char const*, ...) [/home/<userName>/.nvm/versions/node/v24.11.1/bin/node]
 3: 0x119e9b3  [/home/<userName>/.nvm/versions/node/v24.11.1/bin/node]
 4: 0xc0a160  [/home/<userName>/.nvm/versions/node/v24.11.1/bin/node]
 5: 0x73b773e76576 

[juanarbol]

Do you have a minimal repro case? Otherwise, there's no way we can help u out.

[Jayx239]

Sorry for not providing that, let me dive into it and see if I can trace a reproducable example. The problem is that theres many layers to my project in various packages so there is a lot of places where this could be triggered. For what it is worth, this is the test cases that trigger it. As you can see, theres a lot of abstraction so it's difficult or impossible to determine rc from these. Again, I'll dive deeper to find a reproducible exmple:

import path from "node:path";
import { getWebservice } from "../dist/app.js";
// @ts-ignore
import express from "@swizzyweb/express";

import { InstanceType, SwerveManager } from "@swizzyweb/swerve";
import { setTimeout } from "node:timers/promises";
import request from "supertest";
import { BrowserLogger } from "@swizzyweb/swizzy-common";
import test from "node:test";
import assert from "node:assert";
import { fileURLToPath } from "node:url";

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

const servicePath = path.join(__dirname, "../");
const appDataRoot = path.join(__dirname, "test-app-data-root");
const appDataPath = path.join(__dirname, "test-app-data-path");
const logLevel = "debug"; //"info";
const port = parseInt(process.env.PORT ?? "3005");
const tableName = "myTable";
const initSleepTime = 10; //ms
const logger = new BrowserLogger({});
test(`SwapCacheDb swerve integration tests`, () => {
  test.it(`should start and stop db`, async () => {
    const app = express();
    const webService = getWebservice({
      port,
      appDataRoot,
      logger,
      serviceArgs: { servicePath, port, forceNoAuth: true },
      appDataPath,
      app,
    });
  });

  test.it(`Should put, get, and delete a record from db`, async () => {
    const app = await express();
    const webService = getWebservice({
      port: port + 1,
      appDataRoot,
      logger,
      serviceArgs: { servicePath, port, forceNoAuth: true },
      appDataPath,
      app,
    });
    await webService.install({});
    await setTimeout(initSleepTime);
    const putRes = await request(app).put(`/db?tableName=${tableName}`).send({
      tableName,
      key: "hello",
      value: "world",
    });

    assert.equal(putRes.status, 200);

    const getRes = await request(app).post(`/db?tableName=${tableName}`).send({
      tableName,
      key: "hello",
    });

    assert.deepEqual(getRes.body, { record: "world" });

    const deleteRes = await request(app)
      .post(`/db/delete?tableName=${tableName}`)
      .send({
        tableName,
        key: "hello",
      });

    assert.equal(deleteRes.status, 200);

    try {
      const getMissingRes = await request(app)
        .post(`/db?tableName=${tableName}`)
        .send({
          tableName,
          key: "hello",
        });
      assert.equal(getMissingRes.status, 404);
    } catch (e: any) {
      assert.equal(e.status, 404);
    }

    await webService.uninstall({});
    await setTimeout(1000);
  });

  test.it(
    `Should put all, get all, and delete all records from db`,
    async () => {
      const app = await express();

      const webService = getWebservice({
        port: port + 2,
        appDataRoot,
        logger,
        serviceArgs: { servicePath, port, forceNoAuth: true },
        appDataPath,
        app,
      });

      await webService.install({});
      await setTimeout(initSleepTime);

      const putRes = await request(app)
        .put(`/db/all?tableName=${tableName}`)
        .send({
          tableName,
          records: [
            {
              key: "hello",
              value: "world",
            },
            {
              key: "goodbye",
              value: "moon",
            },
          ],
        });

      assert.equal(putRes.status, 200);

      const getRes = await request(app)
        .post(`/db/all?tableName=${tableName}`)
        .send({ tableName, keys: ["hello", "goodbye"] });

      assert.deepEqual(getRes.body, {
        resultSet: "All",
        records: [
          { key: "hello", value: "world" },

          { key: "goodbye", value: "moon" },
        ],
      });

      const deleteRes = await request(app)
        .post(`/db/all/delete?tableName=${tableName}`)
        .send({
          tableName,
          keys: ["hello", "goodbye"],
        });

      assert.equal(deleteRes.status, 200);

      try {
        const getMissingRes = await request(app)
          .post(`/db/all?tableName=${tableName}`)
          .send({
            tableName,
            key: ["hello", "goodbye"],
          });
        assert.equal(getMissingRes.status, 404);
      } catch (e: any) {
        assert.equal(e.status, 404);
      }

      await webService.uninstall({});
      await setTimeout(1000);
    },
  );

  test.it(
    `Should put all, query records, and delete all records from db`,
    async () => {
      const app = await express();

      const webService = getWebservice({
        port: port + 3,
        appDataRoot,
        logger,
        serviceArgs: { servicePath, port, forceNoAuth: true },
        appDataPath,
        app,
      });

      await webService.install({});
      await setTimeout(initSleepTime);

      const putRes = await request(app)
        .put(`/db/all?tableName=${tableName}`)
        .send({
          tableName,
          records: [
            {
              key: "hello",
              value: "world",
            },
            {
              key: "goodbye",
              value: "moon",
            },
          ],
        });

      assert.equal(putRes.status, 200);

      const queryRes = await request(app)
        .post(`/db/query?tableName=${tableName}`)
        .send({ tableName, key: "hello", keyOperator: "=" });

      assert.deepEqual(queryRes.body, {
        recordCount: 1,
        records: [{ key: "hello", value: "world" }],
      });
      const query2Res = await request(app)
        .post(`/db/query?tableName=${tableName}`)
        .send({ tableName, value: "moon", valueOperator: "=" });

      assert.deepEqual(query2Res.body, {
        recordCount: 1,
        records: [{ key: "goodbye", value: "moon" }],
      });

      const deleteRes = await request(app)
        .post(`/db/all/delete?tableName=${tableName}`)
        .send({
          tableName,
          keys: ["hello", "goodbye"],
        });

      assert.equal(deleteRes.status, 200);

      const getMissingRes = await request(app)
        .post(`/db/query?tableName=${tableName}`)
        .send({
          tableName,
          key: ["hello", "goodbye"],
        });
      assert.deepEqual(getMissingRes.body, { recordCount: 0, records: [] });

      await webService.uninstall({});
      await setTimeout(1000);
    },
  );
});

async function stopWebServices(swerve: SwerveManager, webServices: any) {
  for (const webService of webServices) {
    await swerve.stop({
      instanceDetails: {
        instanceId: webService.instanceId,
        instanceType: InstanceType.webservice,
      },
    });
  }
}