Node.jsカスタムインストゥルメンテーション

const nr = require('newrelic');
const app = require('http').createServer();
const io = require('socket.io')(app);

io.on('connection', function(socket) {
  socket.on('ping', function(data) {
    nr.startWebTransaction('/websocket/ping', function transactionHandler() {
      // Ended automatically after synchronously returning
      socket.emit('pong');
    });
  });
  socket.on('update', function(data) {
    nr.startWebTransaction('/websocket/update', function transactionHandler() {
      // Using API getTransaction
      const transaction = nr.getTransaction();
      updateChatWindow(data, function transactionHandler() {
        socket.emit('update-done');
        transaction.end();
      });
    });
  });
  socket.on('new-message', function(data) {
    nr.startWebTransaction('/websocket/new-message', function transactionHandler() {
      // Returning a promise
      return new Promise(function(resolve, reject) {
        addMessageToChat(data, function() {
          socket.emit('message-received');
          resolve();
        });
      });
    });
  });
});

const nr = require('newrelic');
const redis = require('redis').createClient();

// Using API getTransaction to manage ending the transaction
setInterval(function() {
  nr.startBackgroundTransaction('update:cache', function transactionHandler() {
    const newValue = someDataGenerator();
    const transaction = nr.getTransaction();

    redis.set('some:cache:key', newValue, function() {
      transaction.end();
    });
  });
}, 30000); // Every 30s

//Using a promise to manage ending the transaction
setInterval(function() {
  nr.startBackgroundTransaction('flush:cache', function transactionHandler() {
    return new Promise(function(resolve, reject) {
      flushCache(redis, function afterFlush(err) {
        if (err) {
          return reject(err);
        }
        resolve();
      });
    });
  });
}, 60 * 60 * 1000);

// Wrap the method in a segment.
nr.startSegment('db:createObject', true, function(cb) {
  // This is recorded as the `db:createObject` segment.
  db.createObject(cb);
}, function(err, result) {
  // This is recorded as the callback to the `db:createObject` segment.
  if (util.handleError(err, res)) {
    return;
  }
  res.write(JSON.stringify(result.rows[0].id));
  res.write('\n');
  res.end();
});

nr.startSegment('pg:connect', true, function(cb) {
  pg.connect(config.db_string, cb);
}, function(err, client, done) {
  if (util.handleError(err, '500', res)) {
    return done();
  }

  nr.startSegment('pg:query', true, function(cb) {
    client.query('SELECT count(*) FROM test_count', cb);
  }, function(err, result) {
    if (util.handleError(err, '500', res)) {
      return done();
    }

    res.write(result.rows[0].count);
    res.write('\n');
  });
});

nr.startSegment('pg:connect', true, function() {
  // This `pg:connect` segment will time until the returned promise
  // either resolves or rejects.
  return pg.connect(config.db_string);
}).then(function(client) {
  // The transaction context is propagated into following promises.
  return nr.startSegment('pg:query', true, function() {
    return client.query('SELECT count(*) FROM test_count');
  }).then(function(result) {
    res.write(result.rows[0].count);
    res.write('\n');
    res.end();
  }, function(err) {
    // Error from querying.
    util.handleError(err, '500', res);
  }).finally(function() {
    return client.release();
  });
}, function(err) {
  // Error from connecting.
  util.handleError(err, '500', res);
});

try {
  const client = await nr.startSegment('pg:connect', true, async () => {
    // Async functions simply return promises, so this example is
    // very similar to the promise one.
    return await pg.connect(config.db_string);
  });

  // The transaction context is propagated into the code following `await`.
  try {
    const result = await nr.startSegment('pg:query', true, async () => {
      return await client.query('SELECT count(*) FROM test_count');
    });

    res.write(result.rows[0].count);
    res.write('\n');
    res.end();
  } catch (err) {
    // Error from querying.
    util.handleError(err, '500', res);
  } finally {
    await client.release();
  }
} catch (err) {
  // Error from connecting.
  util.handleError(err, '500', res);
}

const result = nr.startSegment('calculateTotal', true, function() {
  return calculateTotal(outerVar1, outerVar2);
});