o11y 246.2.0 → 246.4.0

package/dist/modules/o11y/client/client.js

@@ -1,4 +1,4 @@
-import { utility, PublicSafety, schemaUtil } from 'o11y/shared';
+import { utility, PublicSafety, schemaUtil, metricsUtility } from 'o11y/shared';
 
 const activity={namespace:"sf.instrumentation",name:"Activity",pbjsSchema:{"nested":{"sf":{"nested":{"instrumentation":{"nested":{"Activity":{"reserved":[[5,5],[7,7]],"fields":{"duration":{"id":3,"type":"double"},"stopReason":{"id":6,"type":"string"},"isRoot":{"id":8,"type":"bool"},"timerOverridden":{"id":12,"type":"uint32"},"name":{"options":{"(meta.max_length)":25},"id":2,"type":"string"},"isSampled":{"id":11,"type":"bool"},"preRootId":{"id":9,"type":"string"},"id":{"id":1,"type":"string"},
 "userPayload":{"id":4,"type":"Payload"},"errorCount":{"id":10,"type":"uint32"},"parentId":{"id":13,"type":"string"}}},"Payload":{"fields":{"payload":{"id":2,"type":"bytes"},"schemaName":{"id":1,"type":"string"}}}}}}}}}};
@@ -1068,14 +1068,20 @@ class LogValidator {
 const logValidator = new LogValidator();
 
 class BucketHistogramImpl {
-    constructor(_name, _ownerName, _ownerAppName, _tags, _buckets) {
+    constructor(_name, _ownerName, _ownerAppName, _tags, _buckets, createdOn, lastUpdatedOn, values) {
         this._name = _name;
         this._ownerName = _ownerName;
         this._ownerAppName = _ownerAppName;
         this._tags = _tags;
         this._buckets = _buckets;
         this._values = new Array();
-        this._createdOn = utility.time().tsNow;
+        this._createdOn = createdOn === undefined ? utility.time().tsNow : createdOn;
+        if (lastUpdatedOn !== undefined) {
+            this._lastUpdatedOn = lastUpdatedOn;
+        }
+        if (values !== undefined) {
+            this._values = values;
+        }
     }
     getName() {
         return this._name;
@@ -1122,13 +1128,19 @@ class BucketHistogramImpl {
 }
 
 class UpCounterImpl {
-    constructor(_name, _ownerName, _ownerAppName, _tags) {
+    constructor(_name, _ownerName, _ownerAppName, _tags, createdOn, lastUpdatedOn, value) {
         this._name = _name;
         this._ownerName = _ownerName;
         this._ownerAppName = _ownerAppName;
         this._tags = _tags;
         this._value = 0;
-        this._createdOn = utility.time().tsNow;
+        this._createdOn = createdOn === undefined ? utility.time().tsNow : createdOn;
+        if (lastUpdatedOn !== undefined) {
+            this._lastUpdatedOn = lastUpdatedOn;
+        }
+        if (value !== undefined) {
+            this._value = value;
+        }
     }
     getName() {
         return this._name;
@@ -1166,13 +1178,19 @@ class UpCounterImpl {
 }
 
 class ValueRecorderImpl {
-    constructor(_name, _ownerName, _ownerAppName, _tags) {
+    constructor(_name, _ownerName, _ownerAppName, _tags, createdOn, lastUpdatedOn, values) {
         this._name = _name;
         this._ownerName = _ownerName;
         this._ownerAppName = _ownerAppName;
         this._tags = _tags;
         this._values = new Array();
-        this._createdOn = utility.time().tsNow;
+        this._createdOn = createdOn === undefined ? utility.time().tsNow : createdOn;
+        if (lastUpdatedOn !== undefined) {
+            this._lastUpdatedOn = lastUpdatedOn;
+        }
+        if (values !== undefined) {
+            this._values = values;
+        }
     }
     getName() {
         return this._name;
@@ -1370,7 +1388,7 @@ class InstrumentationImpl {
         return new MetricsImpl(this.name, () => this._nextGen.appName || InstrumentationImpl.defaultAppName);
     }
     _incrementError(increment = 1) {
-        this._metrics.incrementCounter(reservedMetricNames.internalError, increment, false);
+        this._metrics.incrementCounter(reservedMetricNames.internalError, increment, true);
     }
     get name() {
         return this._name;
@@ -1848,9 +1866,190 @@ class AutomaticClickTracker {
     }
 }
 
+const MESSAGE_FROM_RECEIVER = 'o11y:receiver';
+var CommState;
+(function (CommState) {
+    CommState[CommState["Unknown"] = 0] = "Unknown";
+    CommState[CommState["Opening"] = 1] = "Opening";
+})(CommState || (CommState = {}));
+class ReceiverConnector {
+    constructor(_logCallback, _metricsCallback, _commErrorCallback) {
+        this._logCallback = _logCallback;
+        this._metricsCallback = _metricsCallback;
+        this._commErrorCallback = _commErrorCallback;
+        this._senders = new Map();
+        utility.requireArgument(this._logCallback, '_logCallback', 'function');
+        utility.requireArgument(this._metricsCallback, '_metricsCallback', 'function');
+        utility.requireArgument(this._commErrorCallback, '_commErrorCallback', 'function');
+    }
+    openComms(sender) {
+        utility.requireArgument(sender, 'sender', 'object');
+        if (!this._senders.has(sender)) {
+            const messageChannel = new MessageChannel();
+            const status = {
+                state: CommState.Opening,
+                port: messageChannel.port1
+            };
+            this._senders.set(sender, status);
+            status.port.onmessage = this._messagePortEventHandler.bind(this);
+            status.port.onmessageerror = this._messagePortErrorHandler.bind(this);
+            sender.postMessage({
+                from: MESSAGE_FROM_RECEIVER,
+                type: MESSAGE_TYPE_HANDSHAKE
+            }, '*', [messageChannel.port2]);
+        }
+    }
+    closeComms(sender) {
+        const status = this._senders.get(sender);
+        if (status) {
+            status.port.onmessage = undefined;
+            status.port.onmessageerror = undefined;
+            this._senders.delete(sender);
+        }
+    }
+    _messagePortEventHandler(e) {
+        if (e.data.type === MESSAGE_TYPE_LOG) {
+            this._logCallback(e.data.data);
+        }
+        else if (e.data.type === MESSAGE_TYPE_METRICS) {
+            this._metricsCallback(e.data.data);
+        }
+    }
+    _messagePortErrorHandler() {
+        this._commErrorCallback();
+    }
+}
+
+const MESSAGE_TYPE_HANDSHAKE = 'handshake';
+const MESSAGE_TYPE_LOG = 'log';
+const MESSAGE_TYPE_METRICS = 'metrics';
+class SenderConnector {
+    constructor(_self, _allowedOrigins) {
+        this._self = _self;
+        this._allowedOrigins = _allowedOrigins;
+        this._messageEventHandlerFunc = this._messageEventHandler.bind(this);
+        this._handshakeComplete = false;
+        this._logBuffer = [];
+        this._metricsBuffer = [];
+        utility.requireArgument(this._self, '_self', 'object');
+        utility.requireArgumentIfDefined(_allowedOrigins, 'allowedOrigins', Array);
+        this._self.addEventListener('message', this._messageEventHandlerFunc);
+    }
+    _messageEventHandler(e) {
+        if (e.data.from === MESSAGE_FROM_RECEIVER &&
+            e.data.type === MESSAGE_TYPE_HANDSHAKE &&
+            e.ports[0] instanceof MessagePort &&
+            utility.isAllowedOrigin(e.origin, this._allowedOrigins)) {
+            this._handshakeComplete = true;
+            this._self.removeEventListener('message', this._messageEventHandlerFunc);
+            this._otherPort = e.ports[0];
+            this._emptyBuffers();
+        }
+    }
+    sendLog(log) {
+        if (!this._handshakeComplete) {
+            this._logBuffer.push(log);
+        }
+        else {
+            this._otherPort.postMessage({
+                type: MESSAGE_TYPE_LOG,
+                data: log
+            });
+        }
+    }
+    sendMetrics(metrics) {
+        if (!this._handshakeComplete) {
+            this._metricsBuffer.push(metrics);
+        }
+        else {
+            this._otherPort.postMessage({
+                type: MESSAGE_TYPE_METRICS,
+                data: metrics
+            });
+        }
+    }
+    _emptyBuffers() {
+        this._logBuffer.forEach((log) => this.sendLog(log));
+        this._metricsBuffer.forEach((metrics) => this.sendMetrics(metrics));
+        this._logBuffer = undefined;
+        this._metricsBuffer = undefined;
+    }
+}
+
+class MetricsStore {
+    constructor() {
+        this._upCounters = [];
+        this._valueRecorders = [];
+        this._bucketHistograms = [];
+    }
+    add(senderMetrics) {
+        var _a, _b, _c;
+        if ((_a = senderMetrics.upCounters) === null || _a === void 0 ? void 0 : _a.length) {
+            this._upCounters.push(...senderMetrics.upCounters.map((it) => new UpCounterImpl(it.name, it.ownerName, it.ownerAppName, metricsUtility.getMetricsTags(it.tags), it.createdTimestamp, it.lastUpdatedTimestamp, it.value)));
+        }
+        if ((_b = senderMetrics.valueRecorders) === null || _b === void 0 ? void 0 : _b.length) {
+            this._valueRecorders.push(...senderMetrics.valueRecorders.map((it) => new ValueRecorderImpl(it.name, it.ownerName, it.ownerAppName, metricsUtility.getMetricsTags(it.tags), it.createdTimestamp, it.lastUpdatedTimestamp, it.values)));
+        }
+        if ((_c = senderMetrics.bucketHistograms) === null || _c === void 0 ? void 0 : _c.length) {
+            this._bucketHistograms.push(...senderMetrics.bucketHistograms.map((it) => new BucketHistogramImpl(it.name, it.ownerName, it.ownerAppName, metricsUtility.getMetricsTags(it.tags), it.buckets, it.createdTimestamp, it.lastUpdatedTimestamp, it.values)));
+        }
+    }
+    getUpCounters() {
+        this._upCounters = this._upCounters.filter((i) => i.getLastUpdatedOn() !== undefined);
+        return this._upCounters;
+    }
+    getValueRecorders() {
+        this._valueRecorders = this._valueRecorders.filter((i) => i.getLastUpdatedOn() !== undefined);
+        return this._valueRecorders;
+    }
+    getBucketHistograms() {
+        this._bucketHistograms = this._bucketHistograms.filter((i) => i.getLastUpdatedOn() !== undefined);
+        return this._bucketHistograms;
+    }
+}
+
+const DEFAULT_POLL_INTERVAL = 1000;
+class SenderCollector {
+    constructor(_connector, _pollInterval) {
+        this._connector = _connector;
+        this._pollInterval = DEFAULT_POLL_INTERVAL;
+        utility.requireArgument(_connector, '_connector', 'object');
+        if (utility.requireArgumentIfDefined(_pollInterval, '_pollInterval', 'number') &&
+            _pollInterval > 0) {
+            this._pollInterval = _pollInterval;
+        }
+    }
+    collect(schema, data, logMeta) {
+        const msg = {
+            schema,
+            data,
+            logMeta
+        };
+        this._connector.sendLog(msg);
+    }
+    receiveMetricsExtractors(extractors) {
+        this._metricsExtractors = extractors;
+        this._collectAndSendMetrics();
+        setInterval(this._collectAndSendMetrics.bind(this), this._pollInterval);
+    }
+    _collectAndSendMetrics() {
+        const metrics = {
+            upCounters: metricsUtility.getUpCounters(this._metricsExtractors.getAllUpCounters()),
+            valueRecorders: metricsUtility.getValueRecorders(this._metricsExtractors.getAllValueRecorders()),
+            bucketHistograms: metricsUtility.getBucketHistograms(this._metricsExtractors.getAllBucketHistograms())
+        };
+        if (metrics.upCounters.length ||
+            metrics.valueRecorders.length ||
+            metrics.bucketHistograms.length) {
+            this._connector.sendMetrics(metrics);
+        }
+    }
+}
+
 const maxInstrumentationLength = 80;
 const truncatedText = '_CUT';
 const maxInstrumentationLengthBeforeTruncated = maxInstrumentationLength - truncatedText.length;
+function noOpFunc() { }
 class NextgenImpl {
     get pagePayloadProvider() {
         return this._pagePayloadProvider;
@@ -1875,6 +2074,9 @@ class NextgenImpl {
         this._isBufferingEnabled = false;
         this._buffer = [];
         this._logCollectionListeners = new Set();
+        this._opMode = 'default';
+        this._isSender = false;
+        this._isReceiver = false;
     }
     registerApp(name, options) {
         var _a;
@@ -1886,10 +2088,30 @@ class NextgenImpl {
         if (instr) {
             throw new Error(`The instrumentation name ${name} is already taken`);
         }
+        this._initOpMode(options === null || options === void 0 ? void 0 : options.operationMode);
+        this._isSender = this._opMode === 'sender';
+        this._isReceiver = this._opMode === 'receiver';
         this._clientSessionId = ((_a = options === null || options === void 0 ? void 0 : options.clientSessionId) === null || _a === void 0 ? void 0 : _a.toString()) || utility.generateUniqueId();
         this._appInstr = new AppInstrumentationImpl(this, name, options === null || options === void 0 ? void 0 : options.allowMultipleRootActivities);
         this._instruments.set(name, this._appInstr);
-        this._isBufferingEnabled = options === null || options === void 0 ? void 0 : options.enableBuffering;
+        if (this._isSender) {
+            const senderCollector = new SenderCollector(new SenderConnector(window, options === null || options === void 0 ? void 0 : options.allowedReceiverOrigins), options === null || options === void 0 ? void 0 : options.senderMetricsPollingInterval);
+            this.registerLogCollector(senderCollector);
+            this.registerMetricsCollector(senderCollector);
+        }
+        else if (this._isReceiver) {
+            this._metricsStore = new MetricsStore();
+            this._receiverConnector = new ReceiverConnector((msg) => {
+                msg.logMeta.receiverClientSessionId = this._clientSessionId;
+                msg.logMeta.receiverRootId = this._appInstr.getSingleRootActivityId();
+                this._multiplex(msg.schema, msg.data, msg.logMeta);
+            }, (msg) => {
+                this._metricsStore.add(msg);
+            }, () => {
+                this._appInstr.incrementCounter('o11y-error-receiver', 1, true);
+            });
+        }
+        this._isBufferingEnabled = !this._isSender && (options === null || options === void 0 ? void 0 : options.enableBuffering);
         const tracing = new Tracing(this.getInstrumentation('Network'), this._idleDetector);
         return {
             log: this._appInstr.log.bind(this._appInstr),
@@ -1904,19 +2126,28 @@ class NextgenImpl {
             activity: this._appInstr.activity.bind(this._appInstr),
             activityAsync: this._appInstr.activityAsync.bind(this._appInstr),
             startRootActivity: this._appInstr.startRootActivity.bind(this._appInstr),
-            registerLogCollector: this.registerLogCollector.bind(this),
-            registerMetricsCollector: this.registerMetricsCollector.bind(this),
+            registerLogCollector: this._isSender ? noOpFunc : this.registerLogCollector.bind(this),
+            registerMetricsCollector: this._isSender
+                ? noOpFunc
+                : this.registerMetricsCollector.bind(this),
             activateClickTracker: this.activateClickTracker.bind(this),
             deactivateClickTracker: this.deactivateClickTracker.bind(this),
             disableBuffering: this.disableBuffering.bind(this),
             promptLogCollection: this.promptLogCollection.bind(this),
-            getClientSessionId: this.getClientSessionId.bind(this)
+            getClientSessionId: this.getClientSessionId.bind(this),
+            getOperationMode: this.getOperationMode.bind(this),
+            startReceiving: this._isReceiver
+                ? this._receiverConnector.openComms.bind(this._receiverConnector)
+                : noOpFunc,
+            stopReceiving: this._isReceiver
+                ? this._receiverConnector.closeComms.bind(this._receiverConnector)
+                : noOpFunc
         };
     }
     getInstrumentation(name) {
         utility.requireArgument(name, 'name', 'string');
         if (name.length > maxInstrumentationLength) {
-            name = name.substr(0, maxInstrumentationLengthBeforeTruncated) + truncatedText;
+            name = name.substring(0, maxInstrumentationLengthBeforeTruncated) + truncatedText;
         }
         let instr = this._instruments.get(name);
         if (!instr) {
@@ -1939,21 +2170,29 @@ class NextgenImpl {
         let schemaSequence = this._seqBySchema.get(schemaId) || 0;
         schemaSequence += 1;
         this._seqBySchema.set(schemaId, schemaSequence);
+        if (!this._isSender) {
+            data = utility.clone(data);
+        }
         const logMeta = {
             timestamp,
             rootId,
             sequence: this._sequence,
             schemaSequence,
             loggerName,
-            pagePayload: pagePayload ? utility.clone(pagePayload) : undefined,
-            appPayload: appPayload ? utility.clone(appPayload) : undefined,
+            pagePayload: pagePayload || undefined,
+            appPayload: appPayload || undefined,
             loggerAppName: this.appName,
             connectionType: utility.getConnectionType(),
-            clientSessionId: this._clientSessionId
+            clientSessionId: this._clientSessionId,
+            age: utility.getAge(timestamp)
         };
         if (this._isBufferingEnabled) {
-            this._buffer.push({ schema, data: utility.clone(data), logMeta });
+            this._buffer.push({ schema, data, logMeta });
         }
+        this._multiplex(schema, data, logMeta);
+        return this._sequence;
+    }
+    _multiplex(schema, data, logMeta) {
         const eligibleCollectors = Array.from(this._logCollectors).filter((collector) => {
             var _a;
             return !this._forceDisabledLogCollectors.has(collector) &&
@@ -1961,10 +2200,9 @@ class NextgenImpl {
         });
         if (eligibleCollectors.length > 0) {
             for (const collector of eligibleCollectors) {
-                const dataClone = utility.clone(data);
                 let failures = this._logCollectorFailures.get(collector) || 0;
                 try {
-                    collector.collect(schema, dataClone, logMeta);
+                    collector.collect(schema, data, logMeta);
                     if (failures > 0) {
                         this._logCollectorFailures.set(collector, failures - 1);
                     }
@@ -1983,7 +2221,6 @@ class NextgenImpl {
                 }
             }
         }
-        return this._sequence;
     }
     getBuffer() {
         return this._buffer;
@@ -2024,8 +2261,7 @@ class NextgenImpl {
         this._logCollectors.add(collector);
         this._logCollectorFailures.set(collector, 0);
         if ((!collector.getIsCollectDisabled || !collector.getIsCollectDisabled()) &&
-            options &&
-            options.retroactive) {
+            (options === null || options === void 0 ? void 0 : options.retroactive)) {
             for (const log of this._buffer) {
                 collector.collect(log.schema, log.data, log.logMeta);
             }
@@ -2044,16 +2280,19 @@ class NextgenImpl {
         });
     }
     _getAllUpCounters() {
+        var _a;
         const arrOfArrs = Array.from(this._instruments.values()).map((instr) => instr.getUpCounters());
-        return arrOfArrs.reduce((pv, cv) => pv.concat(cv), []);
+        return arrOfArrs.reduce((pv, cv) => pv.concat(cv), ((_a = this._metricsStore) === null || _a === void 0 ? void 0 : _a.getUpCounters()) || []);
     }
     _getAllValueRecorders() {
+        var _a;
         const arrOfArrs = Array.from(this._instruments.values()).map((instr) => instr.getValueRecorders());
-        return arrOfArrs.reduce((pv, cv) => pv.concat(cv), []);
+        return arrOfArrs.reduce((pv, cv) => pv.concat(cv), ((_a = this._metricsStore) === null || _a === void 0 ? void 0 : _a.getValueRecorders()) || []);
     }
     _getAllBucketHistograms() {
+        var _a;
         const arrOfArrs = Array.from(this._instruments.values()).map((instr) => instr.getBucketHistograms());
-        return arrOfArrs.reduce((pv, cv) => pv.concat(cv), []);
+        return arrOfArrs.reduce((pv, cv) => pv.concat(cv), ((_a = this._metricsStore) === null || _a === void 0 ? void 0 : _a.getBucketHistograms()) || []);
     }
     registerForLogPrompt(listener) {
         this._logCollectionListeners.add(listener);
@@ -2073,6 +2312,23 @@ class NextgenImpl {
     getClientSessionId() {
         return this._clientSessionId;
     }
+    _initOpMode(opMode) {
+        if (typeof opMode === 'function') {
+            opMode = opMode();
+        }
+        if (opMode === undefined || typeof window !== 'object') {
+            opMode = 'default';
+        }
+        if (['default', 'receiver', 'sender'].indexOf(opMode) >= 0) {
+            this._opMode = opMode;
+        }
+        else {
+            throw new Error(`Invalid operation mode: ${opMode}`);
+        }
+    }
+    getOperationMode() {
+        return this._opMode;
+    }
 }
 NextgenImpl._collectorFailureLimit = 5;
 
@@ -2142,7 +2398,7 @@ class ConsoleCollector {
     }
 }
 
-const version = '246.2.0';
+const version = '246.4.0';
 
 const idleDetector = new IdleDetectorImpl({
     logThreshold: 300,