Support Meteor 3

.envrc

@@ -0,0 +1,18 @@
+#
+# This is file is intended to store and document useful commands which cannot simply be added to the package.json scripts section.
+#
+
+export METEOR_CHECKOUT_BIN=~/Repositories/meteor/meteor/meteor
+
+function @test-checkout {
+  # No longer needed in Meteor 3.0
+  # export DISABLE_FIBERS=1
+  # export IGNORE_ASYNC_PLUGIN=1
+  # export MONGO_OPLOG_URL=mongodb://localhost:3001/local
+  export METEOR_PACKAGE_DIRS=~/Repositories/monti-apm/monti-apm-agent/packages
+
+  # Overrides Meteor's default behavior
+  export FORCE_COLOR=true
+
+  arch -arm64 $METEOR_CHECKOUT_BIN test-packages ./ --raw-logs "$@"
+}

.github/workflows/test.yml

@@ -12,27 +12,8 @@ jobs:
       fail-fast: false
       matrix:
         meteorRelease:
-          - '--release 1.4.4.6'
-          - '--release 1.5.4.1'
-          - '--release 1.6.0.1'
-          - '--release 1.7.0.5'
-          - '--release 1.8.1'
-          - '--release 1.8.3'
-          - '--release 1.9.1'
-          - '--release 1.10.2'
-          - '--release 1.11'
-          - '--release 1.12.1'
-          - '--release 2.1.1'
-          - '--release 2.2'
-          - '--release 2.3.2'
-          - '--release 2.4.1'
-          - '--release 2.5.6'
-          - '--release 2.6.1'
-          - '--release 2.7.3'
-          - '--release 2.8.2'
-          - '--release 2.9.0'
-          # Latest version
-          -
+          # Meteor 3 Alpha
+          - '--release 3.0-alpha.6'
     steps:
       - name: Checkout code
         uses: actions/checkout@v2

.gitignore

@@ -5,4 +5,4 @@ smart.lock
 versions.json
 .idea
 .eslintcache
-.envrc
+packages/

lib/als/als.js

@@ -0,0 +1,35 @@
+import fs from 'fs';
+import util from 'util';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import crypto from 'crypto';
+
+export const getId = () => crypto.randomUUID();
+
+export const MontiAsyncStorage = new AsyncLocalStorage();
+export const MontiEnvironmentVariable = new AsyncLocalStorage();
+
+export const runWithALS = (
+  fn,
+  storage = MontiAsyncStorage,
+  store = { id: getId(), info: null, env: {}, activeEvent: null }
+) => function (...args) {
+  return storage.run(store, () => fn.apply(this, args));
+};
+
+export const getStore = () => MontiAsyncStorage.getStore() ?? {};
+
+export const getInfo = () => MontiAsyncStorage.getStore()?.info;
+
+export const setActiveEvent = (event, store = MontiAsyncStorage.getStore()) => {
+  if (!store) return;
+
+  MontiAsyncStorage.enterWith({ ...store, activeEvent: event });
+};
+
+export const getActiveEvent = (store = MontiAsyncStorage.getStore()) => store?.activeEvent;
+
+export const runWithEnvironment = (fn, store = new Map([['env', {}]])) => runWithALS(fn, MontiEnvironmentVariable, store);
+
+export const debug = label => (...args) => {
+  fs.writeFileSync(1, `${util.format(label, ...args)}\n`, { flag: 'a' });
+};

lib/als/async-hook.js

@@ -0,0 +1,150 @@
+import asyncHooks from 'async_hooks';
+import { getActiveEvent, getInfo } from './als';
+import { EventType } from '../constants';
+import { Ntp } from '../ntp';
+import { checkForNested } from '../tracer/tracer';
+import { stackTrace } from '../utils';
+
+const getResource = (asyncId) => {
+  if (!asyncId) return;
+
+  const info = getInfo();
+
+  if (!info) return;
+
+  return info.resources.get(asyncId);
+};
+
+export const isDescendantOf = (asyncId, parentAsyncId) => {
+  const resource = getResource(asyncId);
+
+  if (!resource) return false;
+
+  if (resource.triggerAsyncId === parentAsyncId) return true;
+
+  const parent = getResource(resource.triggerAsyncId);
+
+  if (!parent) return false;
+
+  return isDescendantOf(parent.asyncId, parentAsyncId);
+};
+
+export const getAncestryChainOfIds = (asyncId) => {
+  const resource = getResource(asyncId);
+
+  if (!resource) return [];
+
+  if (!resource.triggerAsyncId) return [asyncId];
+
+  const parent = getResource(resource.triggerAsyncId);
+
+  if (!parent) return [asyncId];
+
+  return [...getAncestryChainOfIds(parent.asyncId), asyncId];
+};
+
+export const getActiveEventResource = () => {
+  const activeEvent = getActiveEvent();
+
+  return getResource(activeEvent?.asyncId);
+};
+
+const captureStartTime = (asyncId) => {
+  const resource = getResource(asyncId);
+
+  if (!resource) return;
+
+  resource.startTime = Ntp._now();
+};
+
+const captureEndTime = (asyncId) => {
+  const resource = getResource(asyncId);
+  if (!resource) return;
+
+  // Some resources do not trigger before/after hooks.
+  if (!resource.startTime) {
+    resource.startTime = resource.initAt;
+  }
+
+  resource.endTime = Ntp._now();
+  resource.duration = resource.endTime - resource.startTime;
+
+  const info = getInfo();
+
+  // We can ignore async events which take less than a millisecond for performance.
+  if (resource.duration === 0) return;
+  if (!info) return;
+
+  // Some events finish after the trace is already processed.
+  if (info.trace.isEventsProcessed) return;
+
+  const activeEvent = getActiveEvent();
+
+  const asyncEvent = {
+    type: EventType.Async,
+    at: resource.startTime,
+    endAt: resource.endTime,
+    asyncId,
+    level: activeEvent?.level + 1 || 0,
+  };
+
+  if (activeEvent && !activeEvent.endAt) {
+    checkForNested(activeEvent);
+    activeEvent.nested.push(asyncEvent);
+  } else {
+    info.trace.events.push(asyncEvent);
+  }
+};
+
+export const AsyncResourceType = {
+  PROMISE: 'PROMISE',
+};
+
+const hook = asyncHooks.createHook({
+  init (asyncId, type, triggerAsyncId) {
+    const info = getInfo();
+
+    if (!info) return;
+
+    // We don't want to capture anything other than promise resources.
+    if (type !== AsyncResourceType.PROMISE) return;
+
+    const activeEvent = getActiveEvent();
+
+    if (activeEvent?.asyncId === asyncId) return;
+
+    const {trace} = info || {};
+
+    if (!trace) return;
+
+    info.resources = info.resources || new Map();
+
+    info.resources.set(asyncId, {
+      asyncId,
+      triggerAsyncId,
+      type,
+      initAt: Ntp._now(),
+      startTime: null,
+      endTime: null,
+      trace: stackTrace(),
+      activeEvent,
+    });
+
+    const trigger = info.resources.get(triggerAsyncId);
+
+    if (trigger) {
+      trigger.children = trigger.children || [];
+      trigger.children.push(asyncId);
+    }
+  },
+
+  before: captureStartTime,
+  after: captureEndTime,
+  promiseResolve: captureEndTime,
+});
+
+hook.enable();
+
+process.once('beforeExit', function () {
+  hook.disable();
+});

lib/auto_connect.js

@@ -44,7 +44,12 @@ Kadira._connectWithSettings = function () {
  * Previously there was two log messages (one for instrumentation,
  * and another for connection), this way we merged both of them.
  */
+
+console.log('Monti APM: Instrumentation started...');
+
 Kadira._startInstrumenting(function () {
   Kadira._connectWithEnv();
   Kadira._connectWithSettings();
-});
+
+  console.log('Monti APM: Instrumentation completed');
+}).catch(console.error);

lib/common/unify.js

@@ -5,14 +5,10 @@ Kadira.options = {};
 
 Monti = Kadira;
 
-if (Meteor.wrapAsync) {
-  Kadira._wrapAsync = Meteor.wrapAsync;
-} else {
-  Kadira._wrapAsync = Meteor._wrapAsync;
-}
+Kadira.wrapAsync = Meteor.wrapAsync;
 
 if (Meteor.isServer) {
-  const EventEmitter = Npm.require('events').EventEmitter;
+  const EventEmitter = require('events').EventEmitter;
   const eventBus = new EventEmitter();
   eventBus.setMaxListeners(0);
 

lib/common/utils.js

@@ -21,6 +21,12 @@ export function getClientArchVersion (arch) {
   }
 }
 
+export function omit (obj, keys) {
+  return Object.keys(obj)
+    .filter(k => !keys.includes(k))
+    .reduce((a, k) => ({ ...a, [k]: obj[k] }), {});
+}
+
 const createStackTrace = () => {
   if (Error.captureStackTrace) {
     let err = {};
@@ -93,6 +99,8 @@ export const getErrorParameters = function (args) {
  * @returns {boolean} True if the object has set any data which is not `null`, `undefined` or an empty string.
  */
 export const objectHasData = function (obj) {
+  if (!obj) return false;
+
   return Object.values(obj).some(val => ![null, undefined, ''].includes(val));
 };
 
@@ -131,3 +139,6 @@ export const millisToHuman = function (milliseconds) {
 
   return builder.join(' ');
 };
+
+
+export const isNumber = n => typeof n === 'number' && !isNaN(n);

lib/constants.js

@@ -0,0 +1,12 @@
+export const EventType = {
+  Async: 'async',
+  Complete: 'complete',
+  Compute: 'compute',
+  Custom: 'custom',
+  DB: 'db',
+  Error: 'error',
+  FS: 'fs',
+  HTTP: 'http',
+  Start: 'start',
+  Wait: 'wait',
+};

lib/docsize_cache.js

@@ -1,5 +1,5 @@
-let LRU = Npm.require('lru-cache');
-let jsonStringify = Npm.require('json-stringify-safe');
+let LRU = require('lru-cache');
+let jsonStringify = require('json-stringify-safe');
 
 export const DocSzCache = function (maxItems, maxValues) {
   this.items = new LRU({max: maxItems});