Domain Module Postmortem

EL

Evan Lucas

Domain Module Postmortem

Usability Issues

Implicit Behavior

It's possible for a developer to create a new domain and then simply run domain.enter(). Which then acts as a catch-all for any exception in the future that couldn't be observed by the thrower. Allowing a module author to intercept the exceptions of unrelated code in a different module. Preventing the originator of the code from knowing about its own exceptions.

Here's an example of how one indirectly linked modules can affect another:

// module a.js
const import bb = 
var require: NodeJS.Require
(id: string) => any
require('./b');
const import cc = 
var require: NodeJS.Require
(id: string) => any
require('./c');

// module b.js
const const d: Domaind = 
var require: NodeJS.Require
(id: string) => any
require('domain').function create(): Domaincreate();
const d: Domaind.NodeJS.EventEmitter<DefaultEventMap>.on<any>(eventName: string | symbol, listener: (...args: any[]) => void): Domainon('error', () => {
  /* silence everything */
});
const d: Domaind.Domain.enter(): voidenter();

// module c.js
const import depdep = 
var require: NodeJS.Require
(id: string) => any
require('some-dep');
import depdep.method(); // Uh-oh! This method doesn't actually exist.
JavaScript

Since module b enters the domain but never exits any uncaught exception will be swallowed. Leaving module c in the dark as to why it didn't run the entire script. Leaving a potentially partially populated module.exports. Doing this is not the same as listening for 'uncaughtException'. As the latter is explicitly meant to globally catch errors. The other issue is that domains are processed prior to any 'uncaughtException' handlers, and prevent them from running.

Another issue is that domains route errors automatically if no 'error' handler was set on the event emitter. There is no opt-in mechanism for this, and automatically propagates across the entire asynchronous chain. This may seem useful at first, but once asynchronous calls are two or more modules deep and one of them doesn't include an error handler the creator of the domain will suddenly be catching unexpected exceptions, and the thrower's exception will go unnoticed by the author.

The following is a simple example of how a missing 'error' handler allows the active domain to hijack the error:

const module "domain"domain = 
var require: NodeJS.Require
(id: string) => any
require('domain');
const module "net"net = 
var require: NodeJS.Require
(id: string) => any
require('net');
const const d: domain.Domaind = module "domain"domain.function create(): domain.Domaincreate();
const d: domain.Domaind.NodeJS.EventEmitter<DefaultEventMap>.on<any>(eventName: string | symbol, listener: (...args: any[]) => void): domain.Domainon('error', err: anyerr => var console: Consoleconsole.Console.error(message?: any, ...optionalParams: any[]): void (+1 overload)error(err: anyerr.message));

const d: domain.Domaind.Domain.run<net.Server>(fn: (...args: any[]) => net.Server, ...args: any[]): net.Serverrun(() =>
  module "net"net
    .function createServer(connectionListener?: (socket: net.Socket) => void): net.Server (+1 overload)createServer(c: net.Socketc => {
      c: net.Socketc.Socket.end(callback?: () => void): net.Socket (+2 overloads)end();
      c: net.Socketc.Socket.write(buffer: Uint8Array | string, cb?: (err?: Error | null) => void): boolean (+1 overload)write('bye');
    })
    .Server.listen(port?: number, hostname?: string, backlog?: number, listeningListener?: () => void): net.Server (+8 overloads)listen(8000)
);
JavaScript

Even manually removing the connection via d.remove(c) does not prevent the connection's error from being automatically intercepted.

Failures that plagues both error routing and exception handling are the inconsistencies in how errors are bubbled. The following is an example of how nested domains will and won't bubble the exception based on when they happen:

const module "domain"domain = 
var require: NodeJS.Require
(id: string) => any
require('domain');
const module "net"net = 
var require: NodeJS.Require
(id: string) => any
require('net');
const const d: domain.Domaind = module "domain"domain.function create(): domain.Domaincreate();
const d: domain.Domaind.NodeJS.EventEmitter<DefaultEventMap>.on<any>(eventName: string | symbol, listener: (...args: any[]) => void): domain.Domainon('error', () => var console: Consoleconsole.Console.error(message?: any, ...optionalParams: any[]): void (+1 overload)error('d intercepted an error'));

const d: domain.Domaind.Domain.run<void>(fn: (...args: any[]) => void, ...args: any[]): voidrun(() => {
  const const server: net.Serverserver = module "net"net
    .function createServer(connectionListener?: (socket: net.Socket) => void): net.Server (+1 overload)createServer(c: net.Socketc => {
      const const e: domain.Domaine = module "domain"domain.function create(): domain.Domaincreate(); // No 'error' handler being set.
      const e: domain.Domaine.Domain.run<never>(fn: (...args: any[]) => never, ...args: any[]): neverrun(() => {
        // This will not be caught by d's error handler.
        function setImmediate<[]>(callback: () => void): NodeJS.Immediate (+1 overload)setImmediate(() => {
          throw new 
var Error: ErrorConstructor
new (message?: string, options?: ErrorOptions) => Error (+1 overload)
Error('thrown from setImmediate');
        });
        // Though this one will bubble to d's error handler.
        throw new 
var Error: ErrorConstructor
new (message?: string, options?: ErrorOptions) => Error (+1 overload)
Error('immediately thrown');
      });
    })
    .Server.listen(port?: number, hostname?: string, backlog?: number, listeningListener?: () => void): net.Server (+8 overloads)listen(8080);
});
JavaScript

It may be expected that nested domains always remain nested, and will always propagate the exception up the domain stack. Or that exceptions will never automatically bubble. Unfortunately both these situations occur, leading to potentially confusing behavior that may even be prone to difficult to debug timing conflicts.

API Gaps

While APIs based on using EventEmitter can use bind() and errback style callbacks can use intercept(), alternative APIs that implicitly bind to the active domain must be executed inside of run(). Meaning if module authors wanted to support domains using a mechanism alternative to those mentioned they must manually implement domain support themselves. Instead of being able to leverage the implicit mechanisms already in place.

Error Propagation

Propagating errors across nested domains is not straight forward, if even possible. Existing documentation shows a simple example of how to close() an http server if there is an error in the request handler. What it does not explain is how to close the server if the request handler creates another domain instance for another async request. Using the following as a simple example of the failing of error propagation:

const 
module d1
const d1: any
d1 = domain.create();

module d1
const d1: any
d1.foo = true; // custom member to make more visible in console

module d1
const d1: any
d1.on('error', er: anyer => {
  /* handle error */
});


module d1
const d1: any
d1.run(() =>
  function setTimeout<[]>(callback: () => void, delay?: number): NodeJS.Timeout (+2 overloads)setTimeout(() => {
    const const d2: anyd2 = domain.create();
    const d2: anyd2.bar = 43;
    const d2: anyd2.on('error', er: anyer => var console: Consoleconsole.Console.error(message?: any, ...optionalParams: any[]): void (+1 overload)error(er: anyer.message, domain._stack));
    const d2: anyd2.run(() => {
      function setTimeout<[]>(callback: () => void, delay?: number): NodeJS.Timeout (+2 overloads)setTimeout(() => {
        function setTimeout<[]>(callback: () => void, delay?: number): NodeJS.Timeout (+2 overloads)setTimeout(() => {
          throw new 
var Error: ErrorConstructor
new (message?: string, options?: ErrorOptions) => Error (+1 overload)
Error('outer');
        });
        throw new 
var Error: ErrorConstructor
new (message?: string, options?: ErrorOptions) => Error (+1 overload)
Error('inner');
      });
    });
  })
);
JavaScript

Even in the case that the domain instances are being used for local storage so access to resources are made available there is still no way to allow the error to continue propagating from d2 back to d1. Quick inspection may tell us that simply throwing from d2's domain 'error' handler would allow d1 to then catch the exception and execute its own error handler. Though that is not the case. Upon inspection of domain._stack you'll see that the stack only contains d2.

This may be considered a failing of the API, but even if it did operate in this way there is still the issue of transmitting the fact that a branch in the asynchronous execution has failed, and that all further operations in that branch must cease. In the example of the http request handler, if we fire off several asynchronous requests and each one then write()'s data back to the client many more errors will arise from attempting to write() to a closed handle. More on this in Resource Cleanup on Exception.

Resource Cleanup on Exception

The following script contains a more complex example of properly cleaning up in a small resource dependency tree in the case that an exception occurs in a given connection or any of its dependencies. Breaking down the script into its basic operations:

'use strict';

const module "domain"domain = 
var require: NodeJS.Require
(id: string) => any
require('domain');
const class EE<T extends EventMap<T> = DefaultEventMap>EE = 
var require: NodeJS.Require
(id: string) => any
require('events');
const module "fs"fs = 
var require: NodeJS.Require
(id: string) => any
require('fs');
const module "net"net = 
var require: NodeJS.Require
(id: string) => any
require('net');
const module "util"util = 
var require: NodeJS.Require
(id: string) => any
require('util');
const const print: anyprint = var process: NodeJS.Processprocess._rawDebug;

const const pipeList: any[]pipeList = [];
const const FILENAME: "/tmp/tmp.tmp"FILENAME = '/tmp/tmp.tmp';
const const PIPENAME: "/tmp/node-domain-example-"PIPENAME = '/tmp/node-domain-example-';
const const FILESIZE: 1024FILESIZE = 1024;
var var uid: numberuid = 0;

// Setting up temporary resources
const const buf: anybuf = var Buffer: BufferConstructorBuffer(const FILESIZE: 1024FILESIZE);
for (var var i: numberi = 0; var i: numberi < const buf: anybuf.length; var i: numberi++) const buf: anybuf[var i: numberi] = ((var Math: MathMath.Math.random(): numberrandom() * 1e3) % 78) + 48; // Basic ASCII
module "fs"fs.function writeFileSync(file: fs.PathOrFileDescriptor, data: string | NodeJS.ArrayBufferView, options?: fs.WriteFileOptions): voidwriteFileSync(const FILENAME: "/tmp/tmp.tmp"FILENAME, const buf: anybuf);

function function ConnectionResource(c: any): voidConnectionResource(c: anyc) {
  class EE<T extends EventMap<T> = DefaultEventMap>EE.NewableFunction.call<EE<EventMap<any>>, []>(this: new () => EE<EventMap<any>>, thisArg: EE<EventMap<any>>): voidcall(this);
  this.ConnectionResource._connection: any_connection = c: anyc;
  this.ConnectionResource._alive: any_alive = true;
  this.ConnectionResource._domain: any_domain = module "domain"domain.function create(): domain.Domaincreate();
  this.ConnectionResource._id: any_id = var Math: MathMath.Math.random(): numberrandom().Number.toString(radix?: number): stringtoString(32).String.substr(from: number, length?: number): stringsubstr(2).String.substr(from: number, length?: number): stringsubstr(0, 8) + ++var uid: numberuid;

  this.ConnectionResource._domain: domain.Domain_domain.Domain.add(emitter: EE | NodeJS.Timer): voidadd(c: anyc);
  this.ConnectionResource._domain: domain.Domain_domain.NodeJS.EventEmitter<DefaultEventMap>.on<any>(eventName: string | symbol, listener: (...args: any[]) => void): domain.Domainon('error', () => {
    this.ConnectionResource._alive: boolean_alive = false;
  });
}
module "util"util.function inherits(constructor: unknown, superConstructor: unknown): voidinherits(
class ConnectionResource
function ConnectionResource(c: any): void
ConnectionResource, class EE<T extends EventMap<T> = DefaultEventMap>EE);


class ConnectionResource
function ConnectionResource(c: any): void
ConnectionResource.Function.prototype: anyprototype.ConnectionResource.end(chunk: any): voidend = function function (local function) end(chunk: any): voidend(chunk: anychunk) {
  this.ConnectionResource._alive: boolean_alive = false;
  this.ConnectionResource._connection: any_connection.end(chunk: anychunk);
  this.emit('end');
};


class ConnectionResource
function ConnectionResource(c: any): void
ConnectionResource.Function.prototype: anyprototype.ConnectionResource.isAlive(): booleanisAlive = function function (local function) isAlive(): booleanisAlive() {
  return this.ConnectionResource._alive: boolean_alive;
};


class ConnectionResource
function ConnectionResource(c: any): void
ConnectionResource.Function.prototype: anyprototype.ConnectionResource.id(): stringid = function function (local function) id(): stringid() {
  return this.ConnectionResource._id: string_id;
};


class ConnectionResource
function ConnectionResource(c: any): void
ConnectionResource.Function.prototype: anyprototype.ConnectionResource.write(chunk: any): anywrite = function function (local function) write(chunk: any): anywrite(chunk: anychunk) {
  this.emit('data', chunk: anychunk);
  return this.ConnectionResource._connection: any_connection.write(chunk: anychunk);
};

// Example begin
module "net"net
  .function createServer(connectionListener?: (socket: net.Socket) => void): net.Server (+1 overload)createServer(c: net.Socketc => {
    const const cr: ConnectionResourcecr = new constructor ConnectionResource(c: any): ConnectionResourceConnectionResource(c: net.Socketc);

    const const d1: domain.Domaind1 = module "domain"domain.function create(): domain.Domaincreate();
    module "fs"fs.function open(path: fs.PathLike, flags: fs.OpenMode | undefined, callback: (err: NodeJS.ErrnoException | null, fd: number) => void): void (+2 overloads)open(
      const FILENAME: "/tmp/tmp.tmp"FILENAME,
      'r',
      const d1: domain.Domaind1.Domain.intercept<(fd: NodeJS.ErrnoException | null) => void>(callback: (fd: NodeJS.ErrnoException | null) => void): (fd: NodeJS.ErrnoException | null) => voidintercept(fd: NodeJS.ErrnoException | nullfd => {
        function streamInParts(fd: any, cr: any, pos: any): voidstreamInParts(fd: NodeJS.ErrnoException | nullfd, const cr: ConnectionResourcecr, 0);
      })
    );

    function pipeData(cr: any): voidpipeData(const cr: ConnectionResourcecr);

    c: net.Socketc.Socket.on(event: "close", listener: (hadError: boolean) => void): net.Socket (+12 overloads)on('close', () => const cr: ConnectionResourcecr.ConnectionResource.end(chunk: any): voidend());
  })
  .Server.listen(port?: number, hostname?: string, backlog?: number, listeningListener?: () => void): net.Server (+8 overloads)listen(8080);

function function streamInParts(fd: any, cr: any, pos: any): voidstreamInParts(fd: anyfd, cr: anycr, pos: anypos) {
  const const d2: domain.Domaind2 = module "domain"domain.function create(): domain.Domaincreate();
  var function (local var) alive: booleanalive = true;
  const d2: domain.Domaind2.NodeJS.EventEmitter<DefaultEventMap>.on<any>(eventName: string | symbol, listener: (...args: any[]) => void): domain.Domainon('error', er: anyer => {
    const print: anyprint('d2 error:', er: anyer.message);
    cr: anycr.end();
  });
  module "fs"fs.function read<Buffer<ArrayBuffer>>(fd: number, buffer: Buffer<ArrayBuffer>, offset: number, length: number, position: fs.ReadPosition | null, callback: (err: NodeJS.ErrnoException | null, bytesRead: number, buffer: Buffer<...>) => void): void (+4 overloads)read(
    fd: anyfd,
    new 
var Buffer: BufferConstructor
new (size: number) => Buffer<ArrayBuffer> (+3 overloads)
Buffer(10),
    0,
    10,
    pos: anypos,
    const d2: domain.Domaind2.Domain.intercept<(bRead: NodeJS.ErrnoException | null, buf: number) => void>(callback: (bRead: NodeJS.ErrnoException | null, buf: number) => void): (bRead: NodeJS.ErrnoException | null, buf: number) => voidintercept((bRead: NodeJS.ErrnoException | nullbRead, buf: numberbuf) => {
      if (!cr: anycr.isAlive()) {
        return module "fs"fs.function close(fd: number, callback?: fs.NoParamCallback): voidclose(fd: anyfd);
      }
      if (cr: anycr._connection.bytesWritten < const FILESIZE: 1024FILESIZE) {
        // Documentation says callback is optional, but doesn't mention that if
        // the write fails an exception will be thrown.
        const const goodtogo: anygoodtogo = cr: anycr.write(buf: numberbuf);
        if (const goodtogo: anygoodtogo) {
          function setTimeout<[]>(callback: () => void, delay?: number): NodeJS.Timeout (+2 overloads)setTimeout(() => function streamInParts(fd: any, cr: any, pos: any): voidstreamInParts(fd: anyfd, cr: anycr, pos: anypos + bRead: NodeJS.ErrnoException | nullbRead), 1000);
        } else {
          cr: anycr._connection.once('drain', () =>
            function streamInParts(fd: any, cr: any, pos: any): voidstreamInParts(fd: anyfd, cr: anycr, pos: anypos + bRead: NodeJS.ErrnoException | nullbRead)
          );
        }
        return;
      }
      cr: anycr.end(buf: numberbuf);
      module "fs"fs.function close(fd: number, callback?: fs.NoParamCallback): voidclose(fd: anyfd);
    })
  );
}

function function pipeData(cr: any): voidpipeData(cr: anycr) {
  const const pname: stringpname = const PIPENAME: "/tmp/node-domain-example-"PIPENAME + cr: anycr.id();
  const const ps: net.Serverps = module "net"net.function createServer(connectionListener?: (socket: net.Socket) => void): net.Server (+1 overload)createServer();
  const const d3: domain.Domaind3 = module "domain"domain.function create(): domain.Domaincreate();
  const const connectionList: any[]connectionList = [];
  const d3: domain.Domaind3.NodeJS.EventEmitter<DefaultEventMap>.on<any>(eventName: string | symbol, listener: (...args: any[]) => void): domain.Domainon('error', er: anyer => {
    const print: anyprint('d3 error:', er: anyer.message);
    cr: anycr.end();
  });
  const d3: domain.Domaind3.Domain.add(emitter: EE | NodeJS.Timer): voidadd(const ps: net.Serverps);
  const ps: net.Serverps.Server.on(event: "connection", listener: (socket: net.Socket) => void): net.Server (+5 overloads)on('connection', conn: net.Socketconn => {
    const connectionList: any[]connectionList.Array<any>.push(...items: any[]): numberpush(conn: net.Socketconn);
    conn: net.Socketconn.Socket.on(event: "data", listener: (data: Buffer) => void): net.Socket (+12 overloads)on('data', () => {}); // don't care about incoming data.
    conn: net.Socketconn.Socket.on(event: "close", listener: (hadError: boolean) => void): net.Socket (+12 overloads)on('close', () => {
      const connectionList: any[]connectionList.Array<any>.splice(start: number, deleteCount?: number): any[] (+1 overload)splice(const connectionList: any[]connectionList.Array<any>.indexOf(searchElement: any, fromIndex?: number): numberindexOf(conn: net.Socketconn), 1);
    });
  });
  cr: anycr.on('data', chunk: anychunk => {
    for (var function (local var) i: numberi = 0; function (local var) i: numberi < const connectionList: any[]connectionList.Array<any>.length: numberlength; function (local var) i: numberi++) {
      const connectionList: any[]connectionList[function (local var) i: numberi].write(chunk: anychunk);
    }
  });
  cr: anycr.on('end', () => {
    for (var function (local var) i: numberi = 0; function (local var) i: numberi < const connectionList: any[]connectionList.Array<any>.length: numberlength; function (local var) i: numberi++) {
      const connectionList: any[]connectionList[function (local var) i: numberi].end();
    }
    const ps: net.Serverps.Server.close(callback?: (err?: Error) => void): net.Serverclose();
  });
  const pipeList: any[]pipeList.Array<any>.push(...items: any[]): numberpush(const pname: stringpname);
  const ps: net.Serverps.Server.listen(path: string, backlog?: number, listeningListener?: () => void): net.Server (+8 overloads)listen(const pname: stringpname);
}

var process: NodeJS.Processprocess.NodeJS.Process.on(event: NodeJS.Signals, listener: NodeJS.SignalsListener): NodeJS.Process (+12 overloads)on('SIGINT', () => var process: NodeJS.Processprocess.NodeJS.Process.exit(code?: number | string | null | undefined): neverexit());
var process: NodeJS.Processprocess.NodeJS.Process.on(event: "exit", listener: NodeJS.ExitListener): NodeJS.Process (+12 overloads)on('exit', () => {
  try {
    for (var function (local var) i: numberi = 0; function (local var) i: numberi < const pipeList: any[]pipeList.Array<any>.length: numberlength; function (local var) i: numberi++) {
      module "fs"fs.function unlinkSync(path: fs.PathLike): voidunlinkSync(const pipeList: any[]pipeList[function (local var) i: numberi]);
    }
    module "fs"fs.function unlinkSync(path: fs.PathLike): voidunlinkSync(const FILENAME: "/tmp/tmp.tmp"FILENAME);
  } catch (function (local var) e: unknowne) {}
});
JavaScript
  • When a new connection happens, concurrently:
    • Open a file on the file system
    • Open Pipe to unique socket
  • Read a chunk of the file asynchronously
  • Write chunk to both the TCP connection and any listening sockets
  • If any of these resources error, notify all other attached resources that they need to clean up and shutdown

As we can see from this example a lot more must be done to properly clean up resources when something fails than what can be done strictly through the domain API. All that domains offer is an exception aggregation mechanism. Even the potentially useful ability to propagate data with the domain is easily countered, in this example, by passing the needed resources as a function argument.

One problem domains perpetuated was the supposed simplicity of being able to continue execution, contrary to what the documentation stated, of the application despite an unexpected exception. This example demonstrates the fallacy behind that idea.

Attempting proper resource cleanup on unexpected exception becomes more complex as the application itself grows in complexity. This example only has 3 basic resources in play, and all of them with a clear dependency path. If an application uses something like shared resources or resource reuse the ability to cleanup, and properly test that cleanup has been done, grows greatly.

In the end, in terms of handling errors, domains aren't much more than a glorified 'uncaughtException' handler. Except with more implicit and unobservable behavior by third-parties.

Resource Propagation

Another use case for domains was to use it to propagate data along asynchronous data paths. One problematic point is the ambiguity of when to expect the correct domain when there are multiple in the stack (which must be assumed if the async stack works with other modules). Also the conflict between being able to depend on a domain for error handling while also having it available to retrieve the necessary data.

The following is a involved example demonstrating the failing using domains to propagate data along asynchronous stacks:

const module "domain"domain = 
var require: NodeJS.Require
(id: string) => any
require('domain');
const module "net"net = 
var require: NodeJS.Require
(id: string) => any
require('net');

const const server: net.Serverserver = module "net"net
  .function createServer(connectionListener?: (socket: net.Socket) => void): net.Server (+1 overload)createServer(c: net.Socketc => {
    // Use a domain to propagate data across events within the
    // connection so that we don't have to pass arguments
    // everywhere.
    const const d: domain.Domaind = module "domain"domain.function create(): domain.Domaincreate();
    const d: domain.Domaind.data = { connection: net.Socketconnection: c: net.Socketc };
    const d: domain.Domaind.Domain.add(emitter: EventEmitter | NodeJS.Timer): voidadd(c: net.Socketc);
    // Mock class that does some useless async data transformation
    // for demonstration purposes.
    const const ds: DataStreamds = new constructor DataStream(cb: any): DataStreamDataStream(function dataTransformed(chunk: any): voiddataTransformed);
    c: net.Socketc.Socket.on(event: "data", listener: (data: Buffer) => void): net.Socket (+12 overloads)on('data', chunk: Buffer<ArrayBufferLike>chunk => const ds: DataStreamds.DataStream.data(chunk: any): voiddata(chunk: Buffer<ArrayBufferLike>chunk));
  })
  .Server.listen(port?: number, listeningListener?: () => void): net.Server (+8 overloads)listen(8080, () => var console: Consoleconsole.Console.log(message?: any, ...optionalParams: any[]): void (+1 overload)log(`listening on 8080`));

function function dataTransformed(chunk: any): voiddataTransformed(chunk: anychunk) {
  // FAIL! Because the DataStream instance also created a
  // domain we have now lost the active domain we had
  // hoped to use.
  module "domain"domain.active.data.connection.write(chunk: anychunk);
}

function function DataStream(cb: any): voidDataStream(cb: anycb) {
  this.DataStream.cb: anycb = cb: anycb;
  // DataStream wants to use domains for data propagation too!
  // Unfortunately this will conflict with any domain that
  // already exists.
  this.DataStream.domain: anydomain = module "domain"domain.function create(): domain.Domaincreate();
  this.DataStream.domain: domain.Domaindomain.data = { inst: thisinst: this };
}


class DataStream
function DataStream(cb: any): void
DataStream.Function.prototype: anyprototype.DataStream.data(chunk: any): voiddata = function function (local function) data(chunk: any): voiddata(chunk: anychunk) {
  // This code is self contained, but pretend it's a complex
  // operation that crosses at least one other module. So
  // passing along "this", etc., is not easy.
  this.DataStream.domain: domain.Domaindomain.Domain.run<void>(fn: (...args: any[]) => void, ...args: any[]): voidrun(function () {
    // Simulate an async operation that does the data transform.
    function setImmediate<[]>(callback: () => void): NodeJS.Immediate (+1 overload)setImmediate(() => {
      for (var function (local var) i: numberi = 0; function (local var) i: numberi < chunk: anychunk.length; function (local var) i: numberi++)
        chunk: anychunk[function (local var) i: numberi] = ((chunk: anychunk[function (local var) i: numberi] + var Math: MathMath.Math.random(): numberrandom() * 100) % 96) + 33;
      // Grab the instance from the active domain and use that
      // to call the user's callback.
      const const self: anyself = module "domain"domain.active.data.inst;
      const self: anyself.cb.call(const self: anyself, chunk: anychunk);
    });
  });
};
JavaScript

The above shows that it is difficult to have more than one asynchronous API attempt to use domains to propagate data. This example could possibly be fixed by assigning parent: domain.active in the DataStream constructor. Then restoring it via domain.active = domain.active.data.parent just before the user's callback is called. Also the instantiation of DataStream in the 'connection' callback must be run inside d.run(), instead of simply using d.add(c), otherwise there will be no active domain.

In short, for this to have a prayer of a chance usage would need to strictly adhere to a set of guidelines that would be difficult to enforce or test.

Performance Issues

A significant deterrent from using domains is the overhead. Using node's built-in http benchmark, http_simple.js, without domains it can handle over 22,000 requests/second. Whereas if it's run with NODE_USE_DOMAINS=1 that number drops down to under 17,000 requests/second. In this case there is only a single global domain. If we edit the benchmark so the http request callback creates a new domain instance performance drops further to 15,000 requests/second.

While this probably wouldn't affect a server only serving a few hundred or even a thousand requests per second, the amount of overhead is directly proportional to the number of asynchronous requests made. So if a single connection needs to connect to several other services all of those will contribute to the overall latency of delivering the final product to the client.

Using AsyncWrap and tracking the number of times init/pre/post/destroy are called in the mentioned benchmark we find that the sum of all events called is over 170,000 times per second. This means even adding 1 microsecond overhead per call for any type of setup or tear down will result in a 17% performance loss. Granted, this is for the optimized scenario of the benchmark, but I believe this demonstrates the necessity for a mechanism such as domain to be as cheap to run as possible.

Looking Ahead

The domain module has been soft deprecated since Dec 2014, but has not yet been removed because node offers no alternative functionality at the moment. As of this writing there is ongoing work building out the AsyncWrap API and a proposal for Zones being prepared for the TC39. At such time there is suitable functionality to replace domains it will undergo the full deprecation cycle and eventually be removed from core.

PrevNode.js Foundation Individual Membership Director election opens Friday, January 20NextNode.js Foundation Individual Membership Now Open
Last Updated
Apr 11, 2016
Reading Time
11 min
Contribute
Edit this page
Table of Contents
  1. Usability Issues
  2. Implicit Behavior
  3. API Gaps
  4. Error Propagation
  5. Resource Cleanup on Exception
  6. Resource Propagation
  7. Performance Issues
  8. Looking Ahead