o11y 238.7.0 → 240.0.0

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

@@ -291,7 +291,9 @@ class ActivityImpl {
         const stopPerfTime = utility.perfNow();
         if (this._usePerf) {
             try {
-                performance.measure(this._perfName, this._perfId);
+                if (this._stopReason !== stopReason.discarded) {
+                    performance.measure(this._perfName, this._perfId);
+                }
                 performance.clearMarks(this._perfId);
                 performance.clearMeasures(this._perfName);
             }
@@ -447,136 +449,170 @@ class DomEventHelpers {
 const singleton = new DomEventHelpers();
 const domEventHelpers = singleton;
 
-const maxFieldLength = 10000;
-const minFieldLength = 0;
-const maxFourBytesPos = 2147483647;
-const maxFourBytesNeg = -2147483648;
+const maxStringLengthAppLimit = 10000;
+const maxItemCountAppLimit = 10000;
+const minUnsigned = 0;
+const maxFourBytes = 2147483647;
+const minFourBytes = -2147483648;
 const maxFourBytesUnsigned = 4294967295;
-const maxEightBytesPos = 9223372036854776000;
-const maxEightBytesNeg = -9223372036854776001;
+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;
+            default:
+                msg = `Unknown error code: ${this.errorCode}`;
+                break;
+        }
+        return `Schema ${schemaId} on field "${key}": ${msg}`;
+    }
+}
 class LogValidator {
-    validate(schema, data) {
+    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);
-        const errorMessage = this.validateFields(data, nestedSchema[schemaTokens.message], nestedSchema, schemaUtil.getSchemaId(schema));
-        if (errorMessage) {
-            throw new Error(errorMessage);
+        this.validateFields(errorInfos, [], data, nestedSchema[schemaTokens.message], nestedSchema, schemaId);
+        if (errorInfos.length && !noThrow) {
+            throw new Error(errorInfos[0].asMessage(schemaId));
         }
+        return errorInfos;
     }
-    validateFields(data, message, custom, schemaId) {
+    validateFields(errorInfos, fieldNames, data, message, descriptor, schemaId) {
         const oneofs = message.oneofs || {};
         const fields = message.fields || {};
-        let errorMessage = undefined;
         for (const key in data) {
             const value = data[key];
             if (!this.isNullOrUndefinedOrEmpty(value)) {
+                const mft = (fieldType, rule) => this.matchFieldTypes(errorInfos, [...fieldNames, key], value, fieldType, descriptor, schemaId, key, rule);
                 if (oneofs[key]) {
-                    errorMessage = this.matchFieldTypes(value, oneofs[key].oneof[0], custom, schemaId, key);
+                    mft(fields[oneofs[key].oneof[0]].type);
                 }
                 else if (fields[key]) {
-                    errorMessage = this.matchFieldTypes(value, fields[key].type, custom, schemaId, key, fields[key].rule);
+                    mft(fields[key].type, fields[key].rule);
                 }
             }
-            if (errorMessage) {
-                return errorMessage;
-            }
         }
-        return undefined;
     }
     isNullOrUndefinedOrEmpty(val) {
         return val === undefined || val === null || val === '';
     }
-    matchFieldTypes(fieldData, fieldType, descriptor, schemaId, key, rule) {
-        let convertedSchemaType;
-        let extraContext = undefined;
+    matchFieldTypes(errorInfos, fieldNames, fieldDataValue, protobufType, descriptor, schemaId, key, rule) {
+        let errorCode;
         if (rule === 'repeated') {
-            let errorMessage = undefined;
-            if (Array.isArray(fieldData)) {
-                for (const index in fieldData) {
-                    errorMessage = this.matchFieldTypes(fieldData[index], fieldType, descriptor, schemaId, key);
-                    if (errorMessage) {
-                        break;
-                    }
+            if (Array.isArray(fieldDataValue)) {
+                if (fieldDataValue.length > maxItemCountAppLimit) {
+                    errorCode = 7;
+                }
+                for (const arrayKey in fieldDataValue) {
+                    this.matchFieldTypes(errorInfos, [...fieldNames, arrayKey], fieldDataValue[arrayKey], protobufType, descriptor, schemaId, key);
                 }
             }
             else {
-                errorMessage = `Schema ${schemaId} on field: ${key}, repeated field should be an array`;
+                errorCode = 1;
+            }
+            if (errorCode) {
+                errorInfos.push(new ValidationEntry(errorCode, fieldNames));
             }
-            return errorMessage;
+            return;
         }
-        switch (fieldType) {
+        let javaScriptType;
+        switch (protobufType) {
             case 'string':
-                convertedSchemaType = 'string';
+                javaScriptType = 'string';
+                if (fieldDataValue.length > maxStringLengthAppLimit) {
+                    errorCode = 6;
+                }
                 break;
             case 'bytes':
-                convertedSchemaType = 'object';
-                if (!(fieldData instanceof Uint8Array)) {
-                    extraContext = `Schema ${schemaId} on field: ${key}, bytes array is malformed`;
+                javaScriptType = 'object';
+                if (!(fieldDataValue instanceof Uint8Array)) {
+                    errorCode = 5;
                 }
                 break;
             case 'bool':
-                convertedSchemaType = 'boolean';
+                javaScriptType = 'boolean';
                 break;
             case 'uint32':
-                convertedSchemaType = 'number';
-                extraContext = this.checkNumberRange(fieldData, maxFourBytesUnsigned, 0, schemaId, key);
+                javaScriptType = 'number';
+                errorCode = this.checkNumberRange(fieldDataValue, minUnsigned, maxFourBytesUnsigned);
                 break;
             case 'int32':
             case 'sint32':
             case 'fixed32':
             case 'sfixed32':
-                convertedSchemaType = 'number';
-                extraContext = this.checkNumberRange(fieldData, maxFourBytesPos, maxFourBytesNeg, schemaId, key);
+                javaScriptType = 'number';
+                errorCode = this.checkNumberRange(fieldDataValue, minFourBytes, maxFourBytes);
                 break;
             case 'uint64':
-                convertedSchemaType = 'number';
-                extraContext = this.checkNumberRange(fieldData, maxEightBytesUnsigned, 0, schemaId, key);
+                javaScriptType = 'number';
+                errorCode = this.checkNumberRange(fieldDataValue, minUnsigned, maxEightBytesUnsigned);
                 break;
             case 'fixed64':
             case 'sfixed64':
             case 'int64':
             case 'sint64':
-                convertedSchemaType = 'number';
-                extraContext = this.checkNumberRange(fieldData, maxEightBytesPos, maxEightBytesNeg, schemaId, key);
+                javaScriptType = 'number';
+                errorCode = this.checkNumberRange(fieldDataValue, minEightBytes, maxEightBytes);
                 break;
             case 'double':
             case 'float':
-                convertedSchemaType = 'number';
-                if (!Number.isFinite(fieldData)) {
-                    extraContext = `Schema ${schemaId} on field: ${key}. Value must be finite`;
+                javaScriptType = 'number';
+                if (!Number.isFinite(fieldDataValue)) {
+                    errorCode = 3;
                 }
                 break;
             default:
-                const ref = {};
-                const keys = Object.keys(descriptor);
-                for (const x in keys) {
-                    ref[keys[x].toLowerCase()] = keys[x];
-                }
-                if (ref[fieldType.toLowerCase()]) {
-                    extraContext = this.validateFields(fieldData, descriptor[ref[fieldType.toLowerCase()]], descriptor, schemaId);
-                    convertedSchemaType = 'object';
+                if (new Set(Object.keys(descriptor)).has(protobufType)) {
+                    this.validateFields(errorInfos, fieldNames, fieldDataValue, descriptor[protobufType], descriptor, schemaId);
+                    javaScriptType = 'object';
                 }
                 break;
         }
-        const fieldLength = (fieldData + '').length;
-        if (typeof fieldData !== convertedSchemaType) {
-            return `Schema ${schemaId} on field: ${key}. Expected type ${fieldType} but received type ${typeof fieldData}`;
+        if (typeof fieldDataValue !== javaScriptType) {
+            errorInfos.push(new ValidationEntry(2, fieldNames, protobufType, typeof fieldDataValue));
         }
-        else if (fieldLength < minFieldLength || fieldLength > maxFieldLength) {
-            return `Schema ${schemaId} on field: ${key}, exceeded maximum or minimum field length`;
+        if (errorCode) {
+            errorInfos.push(new ValidationEntry(errorCode, fieldNames));
         }
-        else if (extraContext) {
-            return extraContext;
-        }
-        return undefined;
     }
-    checkNumberRange(value, max, min, schemaId, key) {
-        if (value > max || value < min) {
-            return `Schema ${schemaId} on field: ${key}, number value is too large or small`;
-        }
-        return undefined;
+    checkNumberRange(value, min, max) {
+        return value > max || value < min ? 4 : undefined;
     }
 }
 const logValidator = new LogValidator();
@@ -883,7 +919,7 @@ class InstrumentationImpl {
         const simpleTextOptions = schemaUtil.getOptions(simple, 'Simple', 'text');
         this._simpleTextMaxLength = simpleTextOptions
             ? simpleTextOptions['(meta.max_length)']
-            : Number.MAX_VALUE;
+            : maxStringLengthAppLimit;
     }
     _initMetrics() {
         return new MetricsImpl(this.name, () => this._nextGen.appName || InstrumentationImpl.defaultAppName);
@@ -900,7 +936,7 @@ class InstrumentationImpl {
             userSchema = simple;
             if (userSchemaOrText) {
                 userData = {
-                    text: userSchemaOrText.substr(0, this._simpleTextMaxLength)
+                    text: userSchemaOrText.substring(0, this._simpleTextMaxLength)
                 };
             }
             else {
@@ -1123,17 +1159,46 @@ class InstrumentationImpl {
     _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;
-            logValidator.validate(savedUserPayload.schema, savedUserPayload.payload);
+            vEntries = logValidator.validate(savedUserPayload.schema, savedUserPayload.payload, true);
+            this._processValidationResults(schemaUtil.getSchemaId(savedUserPayload.schema), savedUserPayload.payload, vEntries);
             data.userPayload = undefined;
         }
-        logValidator.validate(schema, data);
+        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());
     }
@@ -1147,6 +1212,34 @@ class InstrumentationImpl {
         utility.requireArgument(listener, 'listener', 'function');
         this._nextGen.registerForLogPrompt(listener);
     }
+    activity(name, execute, options) {
+        var _a, _b, _c, _d;
+        const act = this.startActivity(name, options);
+        try {
+            return execute(act);
+        }
+        catch (err) {
+            act.error(err, (_a = options === null || options === void 0 ? void 0 : options.errorPayload) === null || _a === void 0 ? void 0 : _a.schema, (_b = options === null || options === void 0 ? void 0 : options.errorPayload) === null || _b === void 0 ? void 0 : _b.payload);
+            throw err;
+        }
+        finally {
+            act.stop((_c = options === null || options === void 0 ? void 0 : options.stopPayload) === null || _c === void 0 ? void 0 : _c.schema, (_d = options === null || options === void 0 ? void 0 : options.stopPayload) === null || _d === void 0 ? void 0 : _d.payload);
+        }
+    }
+    async activityAsync(name, execute, options) {
+        var _a, _b, _c, _d;
+        const act = this.startActivity(name, options);
+        try {
+            return await execute(act);
+        }
+        catch (err) {
+            act.error(err, (_a = options === null || options === void 0 ? void 0 : options.errorPayload) === null || _a === void 0 ? void 0 : _a.schema, (_b = options === null || options === void 0 ? void 0 : options.errorPayload) === null || _b === void 0 ? void 0 : _b.payload);
+            throw err;
+        }
+        finally {
+            act.stop((_c = options === null || options === void 0 ? void 0 : options.stopPayload) === null || _c === void 0 ? void 0 : _c.schema, (_d = options === null || options === void 0 ? void 0 : options.stopPayload) === null || _d === void 0 ? void 0 : _d.payload);
+        }
+    }
 }
 InstrumentationImpl.defaultAppName = 'APP_NOT_REGISTERED';
 
@@ -1355,6 +1448,8 @@ class NextgenImpl {
             bucketValue: this._appInstr.bucketValue.bind(this._appInstr),
             networkInstrumentation: tracing.networkInstrumentation.bind(tracing),
             registerForLogPrompt: this._appInstr.registerForLogPrompt.bind(this._appInstr),
+            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),
@@ -1504,7 +1599,10 @@ class NextgenImpl {
             try {
                 listener(reason);
             }
-            catch (_a) {
+            catch (err) {
+                if (!utility.isProduction) {
+                    throw err;
+                }
             }
         }
     }