proteus-js-client/dist/tracing/tracer.js

Proteus JavaScript Client

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.BasicTracer = undefined;

var _opentracing = require('opentracing');

var _span = require('./span');

var _span2 = _interopRequireDefault(_span);

var _propagation = require('./propagation');

var _sampler = require('./sampler');

var _recorder = require('./recorder');

var _proteusJsClient = require('proteus-js-client');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

// Implement https://github.com/opentracing/opentracing-javascript/blob/master/src/tracer.js
var BasicTracer = exports.BasicTracer = function (_Tracer) {
  _inherits(BasicTracer, _Tracer);

  /**
   * Constructs basic tracer instance with provided Sampler and Recorder
   * @param  {Object} options
   *         Optional associative array of fields.
   *         - `sampler` {Sampler} Optional object with `isSample` method, the
   *             method provided with current span as arguments, return
   *             Boolean value indicate whether should take current span
   *             as sample. See src/sample.js for example.
   *         - `recorder` {Recorder} Optional object with `record` method, the
   *             method take span and do whatever required to record a span.
   *             See src/recorder.js for example.
   *
   * @return {BasicTracer}
   */
  function BasicTracer() {
    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
        sampler = _ref.sampler,
        recorder = _ref.recorder;

    var gateway = arguments[1];
    var url = arguments[2];
    var localService = arguments[3];
    var remoteService = arguments[4];
    var shared = arguments[5];

    _classCallCheck(this, BasicTracer);

    var _this = _possibleConstructorReturn(this, _Tracer.call(this));

    _this._sampler = sampler || new _sampler.DefaultSampler();
    var proteusGateway = gateway || _proteusJsClient.Proteus.create({
      setup: {
        group: 'default-tracer-demo',
        accessKey: 9007199254740991,
        accessToken: 'kTBDVtfRBO4tHOnZzSyY5ym2kfY='
      },
      transport: {
        url: url
      }
    });

    _this._recorder = recorder || new _recorder.ZipkinRecorder(proteusGateway, localService, remoteService, shared);
    _this._textPropagator = new _propagation.TextMapPropagator(_this);
    return _this;
  }

  BasicTracer.prototype.setInterface = function setInterface(inf) {
    this._interface = inf;
  };

  BasicTracer.prototype.startSpan = function startSpan(name, fields) {
    // Interface or Implementation argument
    // https://github.com/opentracing/opentracing-javascript/pull/29
    if (fields.parent) {
      fields.childOf = fields.childOf.imp();
    }
    return new _span2.default(this, {
      operationName: name,
      parent: fields.childOf,
      startTime: fields.startTime,
      tags: fields.tags
    });
  };

  BasicTracer.prototype.inject = function inject(span, format, carrier) {
    if (format === _opentracing.FORMAT_TEXT_MAP) {
      this._textPropagator.inject(span, carrier);
    }
  };

  BasicTracer.prototype.extract = function extract(format, carrier) {
    var span = void 0;
    if (format === _opentracing.FORMAT_TEXT_MAP) {
      span = this._textPropagator.extract(carrier);
    }
    return span;
  };

  BasicTracer.prototype.join = function join(operationName, format, carrier) {
    var span = void 0;
    if (format === _opentracing.FORMAT_TEXT_MAP) {
      span = this._textPropagator.join(operationName, carrier);
    }
    return span;
  };

  BasicTracer.prototype._isSampled = function _isSampled(span, parent) {
    return this._sampler.isSampled(span, parent);
  };

  BasicTracer.prototype._record = function _record(span) {
    this._recorder.record(span);
  };

  return BasicTracer;
}(_opentracing.Tracer);