o11y 248.6.0 → 248.7.0

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

@@ -1,5 +1,5 @@
 import { simpleSchema, errorSchema, activitySchema, instrumentedEventSchema, idleDetectorReportSchema } from 'o11y_schema/sf_instrumentation';
-import { utility, PublicSafety, schemaUtil, metricsUtility } from 'o11y/shared';
+import { utility, PublicSafety, schemaUtil, maxStringLengthAppLimit, metricsUtility, payloadUtility } from 'o11y/shared';
 
 class TaskerImpl {
     get isBusy() {
@@ -859,213 +859,6 @@ class DomEventHelpers {
 const singleton = new DomEventHelpers();
 const domEventHelpers = singleton;
 
-const maxStringLengthAppLimit = 10000;
-const maxItemCountAppLimit = 10000;
-const minUnsigned = 0;
-const maxFourBytes = 2147483647;
-const minFourBytes = -2147483648;
-const maxFourBytesUnsigned = 4294967295;
-const maxEightBytes = 9223372036854776000;
-const minEightBytes = -9223372036854776001;
-const maxEightBytesUnsigned = 18446744073709552000;
-class ValidationEntry {
-    constructor(errorCode, fields, expected, received) {
-        this.errorCode = errorCode;
-        this.fields = fields;
-        this.expected = expected;
-        this.received = received;
-    }
-    asMessage(schemaId) {
-        const key = this.fields[0] +
-            this.fields
-                .slice(1)
-                .reduce((prev, current) => Number(current) >= 0 ? `${prev}[${current}]` : `${prev}.${current}`, '');
-        let msg;
-        switch (this.errorCode) {
-            case 1:
-                msg = 'Repeated field must be an array';
-                break;
-            case 2:
-                msg = `Expected type ${this.expected} but received type ${this.received}`;
-                break;
-            case 3:
-                msg = 'Value must be finite';
-                break;
-            case 4:
-                msg = 'Value is out of range for its type';
-                break;
-            case 5:
-                msg = 'Bytes array is malformed';
-                break;
-            case 6:
-                msg = 'Exceeded app limit for maximum string length';
-                break;
-            case 7:
-                msg = 'Exceeded app limit for item count';
-                break;
-            case 12:
-                msg = 'Value must be an integer';
-                break;
-            case 13:
-                msg = 'Values like null or undefined are not allowed for items in repeated fields';
-                break;
-            default:
-                msg = `Unknown error code: ${this.errorCode}`;
-                break;
-        }
-        return `Schema ${schemaId} on field "${key}": ${msg}`;
-    }
-}
-class LogValidator {
-    validate(schema, data, noThrow = false) {
-        const schemaTokens = schemaUtil.checkSchema(schema);
-        utility.requireArgument(data, 'data', 'object');
-        const schemaId = schemaUtil.getSchemaId(schema);
-        const errorInfos = new Array();
-        const nestedSchema = schemaUtil.getTypes(schema);
-        this._validateFields(errorInfos, [], data, nestedSchema[schemaTokens.message], nestedSchema, schemaId);
-        if (errorInfos.length && !noThrow) {
-            throw new Error(errorInfos[0].asMessage(schemaId));
-        }
-        return errorInfos;
-    }
-    _validateFields(errorInfos, fieldNames, data, message, descriptor, schemaId) {
-        const oneofs = message.oneofs || {};
-        const fields = message.fields || {};
-        for (const key in data) {
-            const value = data[key];
-            if (value !== undefined && value !== null) {
-                const mft = (fieldType, isRepeated, isItem) => this._matchFieldTypes(errorInfos, [...fieldNames, key], value, fieldType, descriptor, schemaId, key, isRepeated, isItem);
-                if (oneofs[key]) {
-                    mft(fields[oneofs[key].oneof[0]].type);
-                }
-                else if (fields[key]) {
-                    mft(fields[key].type, fields[key].rule === 'repeated');
-                }
-            }
-        }
-    }
-    _matchFieldTypes(errorInfos, fieldNames, fieldDataValue, protobufType, descriptor, schemaId, key, isRepeated, isItem) {
-        let errorCode;
-        if (isRepeated) {
-            if (Array.isArray(fieldDataValue)) {
-                if (fieldDataValue.length > maxItemCountAppLimit) {
-                    errorCode = 7;
-                }
-                fieldDataValue.forEach((value, index) => {
-                    this._matchFieldTypes(errorInfos, [...fieldNames, index.toString()], value, protobufType, descriptor, schemaId, key, undefined, true);
-                });
-            }
-            else {
-                errorCode = 1;
-            }
-        }
-        else if (fieldDataValue == null || fieldDataValue === undefined) {
-            if (isItem) {
-                errorCode = 13;
-            }
-        }
-        else {
-            let numOpts;
-            let javaScriptType;
-            switch (protobufType) {
-                case 'string':
-                    javaScriptType = 'string';
-                    if (fieldDataValue.length > maxStringLengthAppLimit) {
-                        errorCode = 6;
-                    }
-                    break;
-                case 'bytes':
-                    javaScriptType = 'object';
-                    if (!(fieldDataValue instanceof Uint8Array)) {
-                        errorCode = 5;
-                    }
-                    break;
-                case 'bool':
-                    javaScriptType = 'boolean';
-                    break;
-                case 'uint32':
-                    javaScriptType = 'number';
-                    numOpts = {
-                        min: minUnsigned,
-                        max: maxFourBytesUnsigned,
-                        isInt: true,
-                        isItem
-                    };
-                    break;
-                case 'int32':
-                case 'sint32':
-                case 'fixed32':
-                case 'sfixed32':
-                    javaScriptType = 'number';
-                    numOpts = {
-                        min: minFourBytes,
-                        max: maxFourBytes,
-                        isInt: true,
-                        isItem
-                    };
-                    break;
-                case 'uint64':
-                    javaScriptType = 'number';
-                    numOpts = {
-                        min: minUnsigned,
-                        max: maxEightBytesUnsigned,
-                        isInt: true,
-                        isItem
-                    };
-                    break;
-                case 'fixed64':
-                case 'sfixed64':
-                case 'int64':
-                case 'sint64':
-                    javaScriptType = 'number';
-                    numOpts = {
-                        min: minEightBytes,
-                        max: maxEightBytes,
-                        isInt: true,
-                        isItem
-                    };
-                    break;
-                case 'double':
-                case 'float':
-                    javaScriptType = 'number';
-                    numOpts = {
-                        min: Number.NEGATIVE_INFINITY,
-                        max: Number.POSITIVE_INFINITY,
-                        isInt: false,
-                        isItem
-                    };
-                    break;
-                default:
-                    if (new Set(Object.keys(descriptor)).has(protobufType)) {
-                        this._validateFields(errorInfos, fieldNames, fieldDataValue, descriptor[protobufType], descriptor, schemaId);
-                        javaScriptType = 'object';
-                    }
-                    break;
-            }
-            if (typeof fieldDataValue !== javaScriptType) {
-                errorInfos.push(new ValidationEntry(2, fieldNames, protobufType, typeof fieldDataValue));
-            }
-            else if (numOpts) {
-                if (numOpts.isInt && !Number.isFinite(fieldDataValue)) {
-                    errorCode = 3;
-                }
-                else if (numOpts.isInt && !Number.isInteger(fieldDataValue)) {
-                    errorCode = 12;
-                }
-                else if (!(!numOpts.isInt && Number.isNaN(fieldDataValue)) &&
-                    !(fieldDataValue >= numOpts.min && fieldDataValue <= numOpts.max)) {
-                    errorCode = 4;
-                }
-            }
-        }
-        if (errorCode) {
-            errorInfos.push(new ValidationEntry(errorCode, fieldNames));
-        }
-    }
-}
-const logValidator = new LogValidator();
-
 class BucketHistogramImpl {
     constructor(_name, _ownerName, _ownerAppName, _tags, _buckets, createdOn, lastUpdatedOn, values) {
         this._name = _name;
@@ -1427,10 +1220,7 @@ class InstrumentationImpl {
         });
     }
     _logInternal(loggerName, schema, data, timestamp, rootId) {
-        this._checkInputs(schema, data);
-        const appPayload = this._getPayloadFromProvider(this._nextGen.appPayloadProvider);
-        const pagePayload = this._getPayloadFromProvider(this._nextGen.pagePayloadProvider);
-        return this._nextGen.addLog(loggerName, schema, data, timestamp, rootId, pagePayload, appPayload);
+        return this._nextGen.addLog(loggerName, schema, data, timestamp, rootId);
     }
     error(error, userSchemaOrText, userData, options) {
         return this._safety.tryCatch(() => {
@@ -1516,13 +1306,6 @@ class InstrumentationImpl {
     _handleActivityError(error, detail) {
         this._errorInternal(error, detail.userSchemaOrText, detail.userData, detail.id, detail.rootId);
     }
-    _getPayloadFromProvider(provider) {
-        const payload = (provider === null || provider === void 0 ? void 0 : provider.getPayload()) || undefined;
-        if (payload) {
-            this._checkInputs(payload.schema, payload.payload);
-        }
-        return payload;
-    }
     domEvent(event, handledBy, userSchemaOrText, userData, options) {
         this._safety.tryCatch(() => {
             var _a;
@@ -1624,49 +1407,6 @@ class InstrumentationImpl {
             this._metrics.bucketValue(operation, value, buckets, hasError, tags);
         });
     }
-    _checkInputs(schema, data) {
-        schemaUtil.checkSchema(schema);
-        utility.requireArgument(data, 'data', 'object');
-        let vEntries;
-        let savedUserPayload;
-        if (data.userPayload !== undefined && schemaUtil.isInternal(schema)) {
-            savedUserPayload = data.userPayload;
-            vEntries = logValidator.validate(savedUserPayload.schema, savedUserPayload.payload, true);
-            this._processValidationResults(schemaUtil.getSchemaId(savedUserPayload.schema), savedUserPayload.payload, vEntries);
-            data.userPayload = undefined;
-        }
-        vEntries = logValidator.validate(schema, data, true);
-        this._processValidationResults(schemaUtil.getSchemaId(schema), data, vEntries);
-        if (savedUserPayload !== undefined) {
-            data.userPayload = savedUserPayload;
-        }
-    }
-    _processValidationResults(schemaId, data, ventries) {
-        for (let i = 0; i < ventries.length; i += 1) {
-            const ei = ventries[i];
-            if (ei.errorCode == 6 ||
-                ei.errorCode == 7) {
-                const lfi = ei.fields.length - 1;
-                const obj = this._traverseFields(data, ei.fields.slice(0, lfi));
-                const field = ei.fields[lfi];
-                if (ei.errorCode == 6) {
-                    obj[field] = obj[field].substring(0, maxStringLengthAppLimit);
-                }
-                else {
-                    obj[field].splice(maxItemCountAppLimit);
-                }
-            }
-            else {
-                throw new Error(ei.asMessage(schemaId));
-            }
-        }
-    }
-    _traverseFields(data, fields) {
-        if (!fields.length) {
-            return data;
-        }
-        return this._traverseFields(data[fields[0]], fields.slice(1));
-    }
     getUpCounters() {
         return this._metrics.getUpCounters().filter((m) => m.getLastUpdatedOn());
     }
@@ -2170,36 +1910,45 @@ class NextgenImpl {
         var _a;
         return (_a = this._appInstr) === null || _a === void 0 ? void 0 : _a.name;
     }
-    addLog(loggerName, schema, data, timestamp, rootId, pagePayload, appPayload) {
+    addLog(loggerName, schema, data, timestamp, rootId) {
+        var _a, _b;
+        payloadUtility.checkInputs(schema, data);
         this._sequence += 1;
         const userSchema = schemaUtil.isInternal(schema) && (data === null || data === void 0 ? void 0 : data.userPayload) ? data.userPayload.schema : schema;
         const schemaId = schemaUtil.getSchemaId(userSchema);
         let schemaSequence = this._seqBySchema.get(schemaId) || 0;
         schemaSequence += 1;
         this._seqBySchema.set(schemaId, schemaSequence);
-        if (!this._isSender) {
-            data = utility.clone(data);
-        }
-        if (typeof this._decimalPoints === 'number') {
-            utility.roundNumbersInObject(data, this._decimalPoints);
-            utility.roundNumbersInObject(pagePayload === null || pagePayload === void 0 ? void 0 : pagePayload.payload, this._decimalPoints);
-            utility.roundNumbersInObject(appPayload === null || appPayload === void 0 ? void 0 : appPayload.payload, this._decimalPoints);
-        }
         const logMeta = {
             timestamp,
             rootId,
             sequence: this._sequence,
             schemaSequence,
             loggerName,
-            pagePayload: pagePayload || undefined,
-            appPayload: appPayload || undefined,
+            pagePayload: undefined,
+            appPayload: undefined,
             loggerAppName: this.appName,
             connectionType: utility.getConnectionType(),
             clientSessionId: this._clientSessionId,
             age: utility.getAge(timestamp)
         };
+        const payloadArgs = {
+            schema,
+            data,
+            logMeta
+        };
+        logMeta.pagePayload = payloadUtility.getPayloadFromProvider(this.pagePayloadProvider, payloadArgs);
+        logMeta.appPayload = payloadUtility.getPayloadFromProvider(this.appPayloadProvider, payloadArgs);
+        if (!this._isSender) {
+            data = utility.clone(data);
+        }
+        if (typeof this._decimalPoints === 'number') {
+            utility.roundNumbersInObject(data, this._decimalPoints);
+            utility.roundNumbersInObject((_a = logMeta.pagePayload) === null || _a === void 0 ? void 0 : _a.payload, this._decimalPoints);
+            utility.roundNumbersInObject((_b = logMeta.appPayload) === null || _b === void 0 ? void 0 : _b.payload, this._decimalPoints);
+        }
         if (this._isBufferingEnabled) {
-            this._buffer.push({ schema, data, logMeta });
+            this._buffer.push(payloadArgs);
         }
         this._multiplex(schema, data, logMeta);
         return this._sequence;
@@ -2410,7 +2159,7 @@ class ConsoleCollector {
     }
 }
 
-const version = '248.6.0';
+const version = '248.7.0';
 
 const idleDetector = new IdleDetectorImpl({
     logThreshold: 300,