@redthreadlabs/tracelog 1.4.0

package/lib/instrumentation/shimmer.js

@@ -0,0 +1,123 @@
+/*
+ * Copyright Elasticsearch B.V. and other contributors where applicable.
+ * Licensed under the BSD 2-Clause License; you may not use this file except in
+ * compliance with the BSD 2-Clause License.
+ */
+
+'use strict';
+
+/**
+ * This file is extracted from the 'shimmer' project copyright by Forrest L
+ * Norvell. It have been modified slightly to be used in the current context.
+ *
+ * https://github.com/othiym23/shimmer
+ *
+ * Original file:
+ *
+ * https://github.com/othiym23/shimmer/blob/master/index.js
+ *
+ * License:
+ *
+ * BSD-2-Clause, http://opensource.org/licenses/BSD-2-Clause
+ */
+
+var symbols = require('../symbols');
+
+var isWrappedSym = Symbol('elasticAPMIsWrapped');
+
+exports.wrap = wrap;
+exports.massWrap = massWrap;
+exports.unwrap = unwrap;
+
+// Do not load agent until used to avoid circular dependency issues.
+var _agent;
+function logger() {
+  if (!_agent) _agent = require('../../');
+  return _agent.logger;
+}
+
+function isFunction(funktion) {
+  return typeof funktion === 'function';
+}
+
+function wrap(nodule, name, wrapper) {
+  if (!nodule || !nodule[name]) {
+    logger().debug('no original function %s to wrap', name);
+    return;
+  }
+
+  if (!wrapper) {
+    logger().debug({ stack: new Error().stack }, 'no wrapper function');
+    return;
+  }
+
+  if (!isFunction(nodule[name]) || !isFunction(wrapper)) {
+    logger().debug('original object and wrapper must be functions');
+    return;
+  }
+
+  if (nodule[name][isWrappedSym]) {
+    logger().debug('function %s already wrapped', name);
+    return;
+  }
+
+  var desc = Object.getOwnPropertyDescriptor(nodule, name);
+  if (desc && !desc.writable) {
+    logger().debug('function %s is not writable', name);
+    return;
+  }
+
+  var original = nodule[name];
+  var wrapped = wrapper(original, name);
+
+  wrapped[isWrappedSym] = true;
+  wrapped[symbols.unwrap] = function elasticAPMUnwrap() {
+    if (nodule[name] === wrapped) {
+      nodule[name] = original;
+      wrapped[isWrappedSym] = false;
+    }
+  };
+
+  nodule[name] = wrapped;
+
+  return wrapped;
+}
+
+function massWrap(nodules, names, wrapper) {
+  if (!nodules) {
+    logger().debug(
+      { stack: new Error().stack },
+      'must provide one or more modules to patch',
+    );
+    return;
+  } else if (!Array.isArray(nodules)) {
+    nodules = [nodules];
+  }
+
+  if (!(names && Array.isArray(names))) {
+    logger().debug('must provide one or more functions to wrap on modules');
+    return;
+  }
+
+  for (const nodule of nodules) {
+    for (const name of names) {
+      wrap(nodule, name, wrapper);
+    }
+  }
+}
+
+function unwrap(nodule, name) {
+  if (!nodule || !nodule[name]) {
+    logger().debug({ stack: new Error().stack }, 'no function to unwrap');
+    return;
+  }
+
+  if (!nodule[name][symbols.unwrap]) {
+    logger().debug(
+      'no original to unwrap to -- has %s already been unwrapped?',
+      name,
+    );
+  } else {
+    return nodule[name][symbols.unwrap]();
+  }
+}

package/lib/instrumentation/span-compression.js

@@ -0,0 +1,239 @@
+/*
+ * Copyright Elasticsearch B.V. and other contributors where applicable.
+ * Licensed under the BSD 2-Clause License; you may not use this file except in
+ * compliance with the BSD 2-Clause License.
+ */
+
+'use strict';
+const STRATEGY_EXACT_MATCH = 'exact_match';
+const STRATEGY_SAME_KIND = 'same_kind';
+
+class SpanCompression {
+  constructor(agent) {
+    this._bufferedSpan = null;
+    this._agent = agent;
+    this.timestamp = null;
+    this.duration = 0;
+    this.composite = {
+      count: 0,
+      sum: 0,
+      compression_strategy: null,
+    };
+  }
+
+  setBufferedSpan(span) {
+    this._bufferedSpan = span;
+  }
+
+  getBufferedSpan() {
+    return this._bufferedSpan;
+  }
+
+  // Compares two spans and returns which compression strategy to use
+  // or returns false if the second span can't be compressed into the
+  // first.
+  //
+  // @param Span compositeSpan
+  // @param Span toCompressSpan
+  // @returns boolean|String
+  _getCompressionStrategy(compositeSpan, toCompressSpan) {
+    if (
+      !this._isEnabled() ||
+      !compositeSpan._serviceTarget ||
+      !toCompressSpan._serviceTarget
+    ) {
+      return false;
+    }
+
+    const isSameKind = this.isSameKind(compositeSpan, toCompressSpan);
+
+    if (!isSameKind) {
+      return false;
+    }
+
+    let strategy = STRATEGY_SAME_KIND;
+    if (compositeSpan.name === toCompressSpan.name) {
+      strategy = STRATEGY_EXACT_MATCH;
+    }
+
+    return strategy;
+  }
+
+  isSameKind(compositeSpan, toCompressSpan) {
+    return (
+      compositeSpan.type === toCompressSpan.type &&
+      compositeSpan.subtype === toCompressSpan.subtype &&
+      compositeSpan._serviceTarget.type ===
+        toCompressSpan._serviceTarget.type &&
+      compositeSpan._serviceTarget.name === toCompressSpan._serviceTarget.name
+    );
+  }
+
+  // Sets initial composite values or confirms strategy matches
+  //
+  // Returns true if spanToCompress can be compressed into compositeSpan,
+  // returns false otherwise.
+  //
+  // @param Span compositeSpan
+  // @param Span spanToCompress
+  // @returns boolean
+  _initCompressionStrategy(compositeSpan, spanToCompress) {
+    if (!this.composite.compression_strategy) {
+      // If no strategy is set, check if strategizable or not. If so,
+      // set initial values.  If not, bail.
+      this.composite.compression_strategy = this._getCompressionStrategy(
+        compositeSpan,
+        spanToCompress,
+      );
+      if (!this.composite.compression_strategy) {
+        return false;
+      }
+
+      // set initial composite context values
+      this.timestamp = compositeSpan.timestamp;
+      this.composite.count = 1;
+      this.composite.sum = compositeSpan._duration;
+    } else {
+      // if so, compare with the compression strat and bail if mismatch
+      const strat = this._getCompressionStrategy(compositeSpan, spanToCompress);
+      if (strat !== this.composite.compression_strategy) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  // Attempts to compression the second span into the first
+  //
+  // @param Span compositeSpan
+  // @param Span spanToCompress
+  // @return boolean
+  tryToCompress(compositeSpan, spanToCompress) {
+    if (!this._isEnabled()) {
+      return false;
+    }
+
+    // sets initial compression strategy value. returns
+    // false if not compression eligable
+    if (!this._initCompressionStrategy(compositeSpan, spanToCompress)) {
+      return false;
+    }
+
+    const isAlreadyComposite = this.isComposite();
+    const canBeCompressed = isAlreadyComposite
+      ? this.tryToCompressComposite(compositeSpan, spanToCompress)
+      : this.tryToCompressRegular(compositeSpan, spanToCompress);
+
+    if (!canBeCompressed) {
+      return false;
+    }
+
+    if (!isAlreadyComposite) {
+      this.composite.count = 1;
+      this.composite.sum = compositeSpan._duration;
+    }
+
+    this.composite.count++;
+    this.composite.sum += spanToCompress._duration;
+    this.duration =
+      (spanToCompress._endTimestamp - compositeSpan.timestamp) / 1000;
+    return true;
+  }
+
+  tryToCompressRegular(compositeSpan, spanToCompress) {
+    if (!this.isSameKind(compositeSpan, spanToCompress)) {
+      return false;
+    }
+
+    if (compositeSpan.name === spanToCompress.name) {
+      if (
+        this.duration <=
+          this._agent._conf.spanCompressionExactMatchMaxDuration * 1000 &&
+        spanToCompress._duration <=
+          this._agent._conf.spanCompressionExactMatchMaxDuration * 1000
+      ) {
+        this.composite.compression_strategy = STRATEGY_EXACT_MATCH;
+        return true;
+      }
+      return false;
+    }
+
+    if (
+      this.duration <=
+        this._agent._conf.spanCompressionSameKindMaxDuration * 1000 &&
+      spanToCompress._duration <=
+        this._agent._conf.spanCompressionSameKindMaxDuration * 1000
+    ) {
+      this.composite.compression_strategy = STRATEGY_SAME_KIND;
+      compositeSpan.name = this._spanNameFromCompositeSpan(compositeSpan);
+      return true;
+    }
+
+    return false;
+  }
+
+  tryToCompressComposite(compositeSpan, spanToCompress) {
+    switch (this.composite.compression_strategy) {
+      case STRATEGY_EXACT_MATCH:
+        return (
+          this.isSameKind(compositeSpan, spanToCompress) &&
+          compositeSpan.name === spanToCompress.name &&
+          spanToCompress._duration <=
+            this._agent._conf.spanCompressionExactMatchMaxDuration * 1000
+        );
+      case STRATEGY_SAME_KIND:
+        return (
+          this.isSameKind(compositeSpan, spanToCompress) &&
+          spanToCompress._duration <=
+            this._agent._conf.spanCompressionSameKindMaxDuration * 1000
+        );
+    }
+  }
+
+  _spanNameFromCompositeSpan(compositeSpan) {
+    const prefix = 'Calls to ';
+    const serviceTarget = compositeSpan._serviceTarget;
+    if (!serviceTarget.type) {
+      if (!serviceTarget.name) {
+        return prefix + 'unknown';
+      } else {
+        return prefix + serviceTarget.name;
+      }
+    } else if (!serviceTarget.name) {
+      return prefix + serviceTarget.type;
+    } else {
+      return prefix + serviceTarget.type + '/' + serviceTarget.name;
+    }
+  }
+
+  _isEnabled() {
+    return this._agent._conf.spanCompressionEnabled;
+  }
+
+  isCompositeSameKind() {
+    return this.composite.compression_strategy === STRATEGY_SAME_KIND;
+  }
+
+  isComposite() {
+    return this.composite.count > 1;
+  }
+
+  // Encodes/Serializes composite span properties
+  // @return Object
+  encode() {
+    return {
+      compression_strategy: this.composite.compression_strategy,
+      count: this.composite.count,
+      sum: this.composite.sum,
+    };
+  }
+}
+
+module.exports = {
+  SpanCompression,
+  constants: {
+    STRATEGY_EXACT_MATCH,
+    STRATEGY_SAME_KIND,
+  },
+};