@dynatrace/react-native-plugin 2.327.2 → 2.331.1

package/lib/next/events/EventData.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SendEventValidation_1 = require("./modifier/SendEventValidation");
+const EventModifierUtil_1 = require("./modifier/EventModifierUtil");
+const EventBuilderUtil_1 = require("./EventBuilderUtil");
+class EventData {
+    constructor() {
+        this.rawEventProperties = {};
+    }
+    addEventProperty(key, value) {
+        this.rawEventProperties[key] = value;
+        return this;
+    }
+    withDuration(duration) {
+        this.duration = duration;
+        return this;
+    }
+    toJSON() {
+        const sanitizedEventProperties = SendEventValidation_1.SendEventValidation.modifyEvent(Object.assign(Object.assign({}, this.rawEventProperties), (0, EventBuilderUtil_1.includeIfDefined)("duration", this.duration)));
+        if (sanitizedEventProperties === null) {
+            return null;
+        }
+        (0, EventModifierUtil_1.flagEventProperties)(sanitizedEventProperties);
+        (0, EventModifierUtil_1.addIsApiReported)(sanitizedEventProperties);
+        return sanitizedEventProperties;
+    }
+}
+exports.default = EventData;

package/lib/next/events/EventPipeline.js

@@ -6,18 +6,21 @@ const ConsoleLogger_1 = require("../../core/logging/ConsoleLogger");
 const BaseDataEventModifier_1 = require("./modifier/BaseDataEventModifier");
 const ValueRestrictionModifier_1 = require("./modifier/ValueRestrictionModifier");
 const ModifyEventValidation_1 = require("./modifier/ModifyEventValidation");
-const ViewInfoCreator_1 = require("./ViewInfoCreator");
 const EventSpecContstants_1 = require("./spec/EventSpecContstants");
+const StringLengthEventModifier_1 = require("./modifier/StringLengthEventModifier");
 class EventPipelineImpl {
     constructor() {
         this.customEventModifierChain = new ModifyEventValidation_1.ModifyEventValidation();
         this.logger = new ConsoleLogger_1.ConsoleLogger('EventPipeline');
     }
     getEventModifierChain() {
+        const stringLengthEventModifier = new StringLengthEventModifier_1.StringLengthEventModifier();
         return [
-            new BaseDataEventModifier_1.BaseDataEventModifier(this.viewInfo),
+            new BaseDataEventModifier_1.BaseDataEventModifier(),
+            stringLengthEventModifier,
             this.customEventModifierChain,
             ValueRestrictionModifier_1.ValueRestrictionModifier,
+            stringLengthEventModifier,
         ];
     }
     insertEvent(event) {
@@ -58,14 +61,5 @@ class EventPipelineImpl {
         this.logger.debug('removeEventModifier()');
         return this.customEventModifierChain.removeEventModifier(eventModifier);
     }
-    generateViewData(name) {
-        this.logger.debug(`generateViewData(${name})`);
-        if (name != null) {
-            this.viewInfo = (0, ViewInfoCreator_1.createViewInfo)(name);
-        }
-    }
-    releaseViewData() {
-        this.viewInfo = undefined;
-    }
 }
 exports.EventPipeline = new EventPipelineImpl();

package/lib/next/events/ExceptionEventData.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SendEventValidation_1 = require("./modifier/SendEventValidation");
+const EventModifierUtil_1 = require("./modifier/EventModifierUtil");
+const EventCreator_1 = require("./EventCreator");
+class ExceptionEventData {
+    constructor(error) {
+        this.rawEventProperties = {};
+        this.error = error;
+    }
+    addEventProperty(key, value) {
+        this.rawEventProperties[key] = value;
+        return this;
+    }
+    toJSON() {
+        const sanitizedEventProperties = SendEventValidation_1.SendEventValidation.modifyEvent(Object.assign({}, this.rawEventProperties));
+        if (sanitizedEventProperties === null) {
+            return null;
+        }
+        const exceptionEvent = Object.assign(Object.assign({}, (0, EventCreator_1.createErrorEvent)(this.error.name, this.error.message, this.error.stack)), sanitizedEventProperties);
+        (0, EventModifierUtil_1.flagEventProperties)(exceptionEvent);
+        (0, EventModifierUtil_1.addIsApiReported)(exceptionEvent);
+        return exceptionEvent;
+    }
+}
+exports.default = ExceptionEventData;

package/lib/next/events/HttpRequestEventData.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ConsoleLogger_1 = require("../../core/logging/ConsoleLogger");
+const TimestampProvider_1 = require("../provider/TimestampProvider");
+const SendEventValidation_1 = require("./modifier/SendEventValidation");
+const EventModifierUtil_1 = require("./modifier/EventModifierUtil");
+const EventBuilderUtil_1 = require("./EventBuilderUtil");
+const logger = new ConsoleLogger_1.ConsoleLogger('HttpRequestEventData');
+class HttpRequestEventData {
+    constructor(url, requestMethod) {
+        this.url = url;
+        this.requestMethod = requestMethod;
+        this.duration = 0;
+        this.rawEventProperties = {};
+        this.hasDroppedProperties = false;
+        this.triedToOverwriteDuration = false;
+        this.requestMethod =
+            requestMethod.toUpperCase();
+    }
+    withDuration(duration) {
+        this.duration = duration;
+        this.triedToOverwriteDuration = true;
+        return this;
+    }
+    withStatusCode(statusCode) {
+        this.statusCode = statusCode;
+        return this;
+    }
+    withReasonPhrase(reasonPhrase) {
+        this.reasonPhrase = reasonPhrase;
+        return this;
+    }
+    withError(error) {
+        this.error = error;
+        return this;
+    }
+    withBytesSent(bytesSent) {
+        this.bytesSent = bytesSent;
+        return this;
+    }
+    withBytesReceived(bytesReceived) {
+        this.bytesReceived = bytesReceived;
+        return this;
+    }
+    withTraceparentHeader(traceparentHeader) {
+        this.traceparentHeader = traceparentHeader;
+        return this;
+    }
+    addEventProperty(key, value) {
+        this.rawEventProperties[key] = value;
+        return this;
+    }
+    toJSON() {
+        if (!this.hasValidMandatoryAttributes()) {
+            logger.debug('toJSON(): Dropped invalid event');
+            return null;
+        }
+        const sanitizedDuration = this.sanitizeDuration();
+        const sanitizedStatusCode = this.sanitizeStatusCode();
+        const sanitizedBytesReceived = this.sanitizeBytesReceived();
+        const sanitizedBytesSent = this.sanitizeBytesSent();
+        const parsedTraceparentHeader = this.traceparentHeader &&
+            this.parseTraceparent(this.traceparentHeader);
+        const traceContextHint = !this.traceparentHeader
+            ? "api_unused"
+            : parsedTraceparentHeader
+                ? "api_set"
+                : "invalid";
+        const hasFailedRequest = this.isStatusCodeError() || !!this.error;
+        const sanitizedEventProperties = SendEventValidation_1.SendEventValidation.modifyEvent(this.rawEventProperties);
+        (0, EventModifierUtil_1.flagEventProperties)(sanitizedEventProperties);
+        return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, sanitizedEventProperties), { ["url.full"]: this.url, ["network.protocol.name"]: 'http', ["http.request.method"]: this.requestMethod, ["request.trace_context_hint"]: traceContextHint, ["duration"]: sanitizedDuration, ["start_time"]: TimestampProvider_1.defaultTimestampProvider.getCurrentTimestamp() -
+                sanitizedDuration }), (this.triedToOverwriteDuration && {
+            ["dt.support.api.overridden_fields"]: [
+                'duration',
+            ],
+        })), (0, EventBuilderUtil_1.includeIfDefined)("http.response.status_code", sanitizedStatusCode)), (0, EventBuilderUtil_1.includeIfDefined)("http.response.reason_phrase", this.reasonPhrase)), (0, EventBuilderUtil_1.includeIfDefined)("request.bytes_sent", sanitizedBytesSent)), (0, EventBuilderUtil_1.includeIfDefined)("request.bytes_received", sanitizedBytesReceived)), { ["characteristics.has_request"]: true, ["characteristics.is_api_reported"]: true }), (0, EventBuilderUtil_1.includeIfTrue)("characteristics.has_failed_request", hasFailedRequest)), (0, EventBuilderUtil_1.includeIfTrue)("characteristics.has_error", hasFailedRequest)), (this.error !== undefined && Object.assign({ ["characteristics.has_exception"]: true, ["exception.type"]: this.error.name, ["exception.message"]: this.error.message }, (0, EventBuilderUtil_1.includeIfDefined)("exception.stack_trace", this.error.stack)))), (parsedTraceparentHeader && {
+            ["trace.id"]: parsedTraceparentHeader.traceId,
+            ["span.id"]: parsedTraceparentHeader.spanId,
+        })), (0, EventBuilderUtil_1.includeIfTrue)("dt.support.api.has_dropped_properties", this.hasDroppedProperties));
+    }
+    hasValidMandatoryAttributes() {
+        let isValid = true;
+        if (this.isInvalidUrl(this.url)) {
+            logger.debug(`hasValidMandatoryAttributes(): dropped event since given URL is malformed: ${this.url}`);
+            isValid = false;
+        }
+        if (!HttpRequestEventData.allowedRequestMethods.includes(this.requestMethod)) {
+            logger.debug(`hasValidMandatoryAttributes(): dropped event since given Request Method is invalid: ${this.requestMethod}`);
+            isValid = false;
+        }
+        return isValid;
+    }
+    isInvalidUrl(url) {
+        try {
+            if (!url.match(/^(https?):\/\/[^\s/$.?#-][^\s]*$/i)) {
+                return true;
+            }
+            new URL(url);
+            return false;
+        }
+        catch (_a) {
+            return true;
+        }
+    }
+    sanitizeStatusCode() {
+        if (this.statusCode !== undefined && this.statusCode < 0) {
+            logger.debug('HttpRequestEventData: dropping invalid Status Code');
+            this.hasDroppedProperties = true;
+            return undefined;
+        }
+        return this.statusCode;
+    }
+    sanitizeDuration() {
+        if (!Number.isFinite(this.duration) || this.duration < 0) {
+            logger.debug('HttpRequestEventData: overriding invalid Duration with 0');
+            this.hasDroppedProperties = true;
+            return 0;
+        }
+        return this.duration;
+    }
+    sanitizeBytesSent() {
+        if (this.bytesSent && this.bytesSent < 0) {
+            logger.debug(`HttpRequestEventData: dropping invalid value for Bytes Sent: ${this.bytesSent}`);
+            this.hasDroppedProperties = true;
+            return undefined;
+        }
+        return this.bytesSent;
+    }
+    sanitizeBytesReceived() {
+        if (this.bytesReceived && this.bytesReceived < 0) {
+            logger.debug(`HttpRequestEventData: dropping invalid value for Bytes Received: ${this.bytesReceived}`);
+            this.hasDroppedProperties = true;
+            return undefined;
+        }
+        return this.bytesReceived;
+    }
+    isStatusCodeError() {
+        return (this.statusCode && 400 <= this.statusCode && this.statusCode <= 599);
+    }
+    parseTraceparent(header) {
+        const traceparentRegex = /^00-([0-9a-f]{32})-([0-9a-f]{16})-0[01]$/;
+        const match = header.match(traceparentRegex);
+        if (!match) {
+            logger.debug("The provided traceparent header does not match the format: '00-<trace-id-32-HEXDIG>-<parent-id-16-HEXDIG>-<trace-flags-2-HEXDIG>'");
+            return null;
+        }
+        const [, traceId, spanId] = match;
+        if (this.allZeros(traceId)) {
+            logger.debug('Trace ID in traceparent header must not be all zeros');
+            return null;
+        }
+        if (this.allZeros(spanId)) {
+            logger.debug('Parent ID in traceparent header must not be all zeros');
+            return null;
+        }
+        return { traceId, spanId };
+    }
+    allZeros(str) {
+        return /^0*$/.test(str);
+    }
+}
+exports.default = HttpRequestEventData;
+HttpRequestEventData.allowedRequestMethods = [
+    'GET',
+    'HEAD',
+    'POST',
+    'PUT',
+    'DELETE',
+    'CONNECT',
+    'OPTIONS',
+    'TRACE',
+    'PATCH',
+];

package/lib/next/events/SessionPropertyEventData.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SendEventValidation_1 = require("./modifier/SendEventValidation");
+const EventModifierUtil_1 = require("./modifier/EventModifierUtil");
+class SessionPropertyEventData {
+    constructor() {
+        this.rawSessionProperties = {};
+    }
+    addSessionProperty(key, value) {
+        this.rawSessionProperties[key] = value;
+        return this;
+    }
+    toJSON() {
+        const event = SendEventValidation_1.SendSessionPropertyEventValidation.modifyEvent(this.rawSessionProperties);
+        if (event != null) {
+            event["characteristics.has_session_properties"] = true;
+        }
+        (0, EventModifierUtil_1.addIsApiReported)(event);
+        return event;
+    }
+}
+exports.default = SessionPropertyEventData;

package/lib/next/events/interface/IBaseEvent.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/next/events/interface/IEventData.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/next/events/interface/IExceptionEventData.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/next/events/interface/IHttpRequestEventData.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/next/events/interface/ISessionPropertyEventData.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/next/events/modifier/BaseDataEventModifier.js

@@ -5,8 +5,7 @@ const ConfigurationHandler_1 = require("../../../core/configuration/Configuratio
 const ConsoleLogger_1 = require("../../../core/logging/ConsoleLogger");
 const EventModifierUtil_1 = require("./EventModifierUtil");
 class BaseDataEventModifier {
-    constructor(viewInfo) {
-        this.viewInfo = viewInfo;
+    constructor() {
         this.logger = new ConsoleLogger_1.ConsoleLogger('BaseDataEventModifier');
     }
     modifyEvent(event) {
@@ -14,7 +13,6 @@ class BaseDataEventModifier {
             this.logger.debug(`modifyEvent(${JSON.stringify(event)}): Event is null!`);
             return event;
         }
-        Object.assign(event, this.viewInfo);
         event["dt.rum.event.source.type"] = 'react_native';
         const bundleName = ConfigurationHandler_1.ConfigurationHandler.getBundleName();
         if (bundleName !== undefined) {

package/lib/next/events/modifier/EventModifierUtil.js

@@ -1,23 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getReactNativeVersion = exports.containEventPropertiesInArray = exports.addIsApiReported = exports.flagEventProperties = exports.containEventProperties = exports.containSessionProperties = exports.trimStringValuesInObject = exports.trimString = exports.isObject = exports.flattenAdditionalData = void 0;
+exports.isKeyCustomProperty = exports.isNotObject = exports.doesNotExceedKeySize = exports.restrictingValueSize = exports.isKeySyntaxAllowed = exports.getReactNativeVersion = exports.containEventPropertiesInArray = exports.addIsApiReported = exports.flagEventProperties = exports.containEventProperties = exports.containSessionProperties = exports.trimString = exports.isObject = void 0;
 const ConsoleLogger_1 = require("../../../core/logging/ConsoleLogger");
-const MAX_STRING_LENGTH_FOR_VALUES = 5000;
+const EventSpecContstants_1 = require("../spec/EventSpecContstants");
 const logger = new ConsoleLogger_1.ConsoleLogger('EventModifierUtil');
-const flattenAdditionalData = (obj, parent, res = {}) => {
-    for (const key in obj) {
-        const propName = parent != null ? parent + '.' + key : key;
-        const valueOfObject = obj[key];
-        if ((0, exports.isObject)(valueOfObject)) {
-            (0, exports.flattenAdditionalData)(valueOfObject, propName, res);
-        }
-        else {
-            res[propName] = obj[key];
-        }
-    }
-    return res;
-};
-exports.flattenAdditionalData = flattenAdditionalData;
 const isObject = (obj) => {
     if (obj === null || typeof obj !== 'object') {
         return false;
@@ -25,25 +11,17 @@ const isObject = (obj) => {
     return Object.prototype.toString.call(obj) === '[object Object]';
 };
 exports.isObject = isObject;
-const trimString = (str, maxLength = MAX_STRING_LENGTH_FOR_VALUES) => {
+const trimString = (key, str, maxLength) => {
     const stringToTrim = str.toString();
     if (stringToTrim.length <= maxLength) {
         return stringToTrim;
     }
     else {
+        logger.debug(`trimString(): Limiting value of ${key} as maximum value length (${maxLength}) is reached!`);
         return stringToTrim.substring(0, maxLength);
     }
 };
 exports.trimString = trimString;
-const trimStringValuesInObject = (jsonData) => {
-    for (const key in jsonData) {
-        if (Object.prototype.hasOwnProperty.call(jsonData, key)) {
-            jsonData[key] = trimStringValue(jsonData[key]);
-        }
-    }
-    return jsonData;
-};
-exports.trimStringValuesInObject = trimStringValuesInObject;
 const containSessionProperties = (jsonData) => {
     for (const key in jsonData) {
         if (key.startsWith(`${"session_properties"}.`)) {
@@ -70,7 +48,7 @@ const flagEventProperties = (event) => {
 };
 exports.flagEventProperties = flagEventProperties;
 const addIsApiReported = (event) => {
-    if (event !== null) {
+    if (event != null) {
         event["characteristics.is_api_reported"] = true;
     }
 };
@@ -101,22 +79,37 @@ const getReactNativeVersion = () => {
     return undefined;
 };
 exports.getReactNativeVersion = getReactNativeVersion;
-const toVersionString = (v) => `${v.major}.${v.minor}.${v.patch}${v.prerelease ? `-${v.prerelease}` : ''}`;
-const trimStringValuesInArray = (arrayData) => {
-    arrayData.forEach((value, index, array) => {
-        array[index] = trimStringValue(value);
-    });
-    return arrayData;
+const isKeySyntaxAllowed = (entry) => {
+    const [key] = entry;
+    const rV = EventSpecContstants_1.KEY_NAME_REGEX.test(key);
+    if (!rV) {
+        logger.debug(`isKeySyntaxAllowed(): Filtering key ${key} as it doesnt fulfill character rules!`);
+    }
+    return rV;
 };
-const trimStringValue = (data) => {
-    if (typeof data === 'string') {
-        return (0, exports.trimString)(data);
+exports.isKeySyntaxAllowed = isKeySyntaxAllowed;
+const restrictingValueSize = (entry) => {
+    const [key, value] = entry;
+    if (typeof value === 'string' &&
+        value.length > EventSpecContstants_1.MAX_CUSTOM_EVENT_VALUE_LENGTH) {
+        logger.debug(`restrictingValueSize(): Limiting value of ${key} as maximum value length (${EventSpecContstants_1.MAX_CUSTOM_EVENT_VALUE_LENGTH}) is reached!`);
+        entry[1] = value.slice(0, EventSpecContstants_1.MAX_CUSTOM_EVENT_VALUE_LENGTH);
     }
-    else if (Array.isArray(data)) {
-        return trimStringValuesInArray(data);
+};
+exports.restrictingValueSize = restrictingValueSize;
+const doesNotExceedKeySize = ([key]) => {
+    if (key.length <= EventSpecContstants_1.MAX_CUSTOM_EVENT_KEY_LENGTH) {
+        return true;
     }
-    else if ((0, exports.isObject)(data)) {
-        return (0, exports.trimStringValuesInObject)(data);
+    else {
+        logger.debug(`doesNotExceedKeySize(): Dropping key ${key} as maximum key length (${EventSpecContstants_1.MAX_CUSTOM_EVENT_KEY_LENGTH}) is reached!`);
+        return false;
     }
-    return data;
 };
+exports.doesNotExceedKeySize = doesNotExceedKeySize;
+const isNotObject = ([, val]) => typeof val !== 'object' || val === null;
+exports.isNotObject = isNotObject;
+const isKeyCustomProperty = (key) => key.startsWith("event_properties") ||
+    key.startsWith("session_properties");
+exports.isKeyCustomProperty = isKeyCustomProperty;
+const toVersionString = (v) => `${v.major}.${v.minor}.${v.patch}${v.prerelease ? `-${v.prerelease}` : ''}`;

package/lib/next/events/modifier/ModifyEventValidation.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModifyEventValidation = void 0;
 const ConsoleLogger_1 = require("../../../core/logging/ConsoleLogger");
 const EventSpecContstants_1 = require("../spec/EventSpecContstants");
-const EventLimitation_1 = require("./EventLimitation");
 const EventModifierUtil_1 = require("./EventModifierUtil");
 class ModifyEventValidation {
     constructor() {
@@ -30,7 +29,7 @@ class ModifyEventValidation {
             for (const modifier of this.customEventModifierChain) {
                 try {
                     const eventRv = modifier.modifyEvent(event);
-                    if (eventRv === null) {
+                    if (!eventRv) {
                         isDiscarded = true;
                         break;
                     }
@@ -53,29 +52,31 @@ class ModifyEventValidation {
         }
         return event;
     }
-    isPropertiesAllowed(key, hasSessionPropertyCharacteristics) {
+    isCustomPropertiesAllowed(key, hasSessionPropertyCharacteristics) {
         if (hasSessionPropertyCharacteristics) {
             if (key.startsWith(`${"event_properties"}.`)) {
                 this.logger.debug(`isPropertiesAllowed(): Filtering key ${key} as usage of event properties is not allowed!`);
-                return true;
+                return false;
             }
         }
         else {
             if (key.startsWith(`${"session_properties"}.`)) {
                 this.logger.debug(`isPropertiesAllowed(): Filtering key ${key} as usage of session properties is not allowed!`);
-                return true;
+                return false;
             }
         }
-        return false;
+        return true;
     }
-    isKeyNameForbidden(key) {
+    isKeyNameForbidden(key, isAdded = false) {
         for (const namespace of EventSpecContstants_1.MODIFY_EVENT_WHITELIST_NAMESPACE) {
             if (key.startsWith(`${namespace}.`)) {
                 return false;
             }
         }
-        if (EventSpecContstants_1.MODIFY_EVENT_WHITELIST_FIELDS.includes(key)) {
-            return false;
+        if (!isAdded) {
+            if (EventSpecContstants_1.MODIFY_EVENT_WHITELIST_FIELDS.includes(key)) {
+                return false;
+            }
         }
         this.logger.debug(`isKeyNameForbidden(): Filtering key ${key} as this field is reserved and must not be overridden!`);
         return true;
@@ -98,22 +99,16 @@ class ModifyEventValidation {
         const restoredEntries = this.restoreRemovedEntries(Object.entries(originalEvent), userEnrichedEvent, overriddenKeys);
         const validAndRestoredEntries = validEntries.concat(restoredEntries);
         const { baseEntries, addedEntries } = this.determineAddedEntries(originalEvent, validAndRestoredEntries);
-        const limitedEntries = new EventLimitation_1.EventLimitation().limitEventEntries(addedEntries);
+        const limitedAddedEntries = this.validateAddedEntries(addedEntries);
         if (originalEvent["characteristics.has_event_properties"] === undefined &&
-            (0, EventModifierUtil_1.containEventPropertiesInArray)(limitedEntries)) {
-            limitedEntries.push([
+            (0, EventModifierUtil_1.containEventPropertiesInArray)(limitedAddedEntries)) {
+            limitedAddedEntries.push([
                 "characteristics.has_event_properties",
                 true,
             ]);
         }
-        const finalEntries = baseEntries.concat(limitedEntries);
-        const sizedEntries = new EventLimitation_1.EventLimitation().limitEventProperties(finalEntries);
-        if (sizedEntries.length < userEnrichedEventEntries.length) {
-            sizedEntries.push([
-                "dt.support.api.has_dropped_custom_properties",
-                true,
-            ]);
-        }
+        const finalEntries = baseEntries.concat(limitedAddedEntries);
+        const sizedEntries = this.enforcePropertyLimit(finalEntries);
         if (Array.isArray(overriddenKeys) && overriddenKeys.length > 0) {
             sizedEntries.push([
                 "dt.support.api.overridden_fields",
@@ -128,31 +123,68 @@ class ModifyEventValidation {
         }
         return Object.fromEntries(sizedEntries);
     }
+    determineChangedContent(modifiedJSONEventEntries, originalJSONEvent) {
+        const changedEntries = [];
+        for (const [prop, value] of modifiedJSONEventEntries) {
+            const originalValue = originalJSONEvent[prop];
+            if (this.isModified(originalValue, value)) {
+                changedEntries.push([prop, value]);
+                continue;
+            }
+        }
+        return changedEntries;
+    }
     determineValidEntries(userEnrichedEntries, originalJSONEvent, overriddenKeys) {
-        const newEntries = [];
+        const validEntries = [];
+        let droppedCustomProperties = false;
+        let droppedProperties = false;
         for (const [prop, value] of userEnrichedEntries) {
             const originalValue = originalJSONEvent[prop];
             if (!this.isModified(originalValue, value)) {
-                newEntries.push([prop, value]);
+                validEntries.push([prop, value]);
                 continue;
             }
-            if (this.isPropertiesAllowed(prop, originalJSONEvent["characteristics.has_session_properties"] === true)) {
+            if (!this.isCustomPropertiesAllowed(prop, originalJSONEvent["characteristics.has_session_properties"] === true)) {
+                droppedCustomProperties = true;
                 continue;
             }
             const isNewlyAdded = typeof originalValue === 'undefined';
-            const isForbiddenKey = this.isKeyNameForbidden(prop);
+            const isForbiddenKey = this.isKeyNameForbidden(prop, isNewlyAdded);
             if (isForbiddenKey) {
                 if (!isNewlyAdded) {
-                    newEntries.push([prop, originalValue]);
+                    validEntries.push([prop, originalValue]);
                 }
+                droppedProperties = true;
                 continue;
             }
             if (!isNewlyAdded && !overriddenKeys.includes(prop)) {
                 overriddenKeys.push(prop);
             }
-            newEntries.push([prop, value]);
+            if (!isNewlyAdded &&
+                EventSpecContstants_1.MODIFY_EVENT_WHITELIST_STRING_FIELDS.includes(prop)) {
+                const maximumLength = Math.max(originalJSONEvent[prop].toString().length, EventSpecContstants_1.MAX_CUSTOM_EVENT_VALUE_LENGTH);
+                validEntries.push([
+                    prop,
+                    (0, EventModifierUtil_1.trimString)(prop, value.toString(), maximumLength),
+                ]);
+            }
+            else {
+                validEntries.push([prop, value]);
+            }
+        }
+        if (droppedCustomProperties) {
+            validEntries.push([
+                "dt.support.api.has_dropped_custom_properties",
+                true,
+            ]);
         }
-        return newEntries;
+        if (droppedProperties) {
+            validEntries.push([
+                "dt.support.api.has_dropped_properties",
+                true,
+            ]);
+        }
+        return validEntries;
     }
     isModified(oldValue, newValue) {
         if (Array.isArray(oldValue)) {
@@ -198,5 +230,63 @@ class ModifyEventValidation {
             return entries;
         }, resultEntries);
     }
+    validateAddedEntries(addedEntries) {
+        const validEntries = [];
+        let droppedProperties = false;
+        let droppedCustomProperties = false;
+        for (const entry of addedEntries) {
+            if (!(0, EventModifierUtil_1.isNotObject)(entry) ||
+                !(0, EventModifierUtil_1.doesNotExceedKeySize)(entry) ||
+                !(0, EventModifierUtil_1.isKeySyntaxAllowed)(entry)) {
+                if ((0, EventModifierUtil_1.isKeyCustomProperty)(entry[0])) {
+                    droppedCustomProperties = true;
+                }
+                else {
+                    droppedProperties = true;
+                }
+                continue;
+            }
+            (0, EventModifierUtil_1.restrictingValueSize)(entry);
+            validEntries.push(entry);
+        }
+        if (droppedCustomProperties) {
+            validEntries.push([
+                "dt.support.api.has_dropped_custom_properties",
+                true,
+            ]);
+        }
+        if (droppedProperties) {
+            validEntries.push([
+                "dt.support.api.has_dropped_properties",
+                true,
+            ]);
+        }
+        return validEntries;
+    }
+    enforcePropertyLimit(entries) {
+        const result = [];
+        let propertyCount = 0;
+        let droppedCustomProperties = false;
+        entries.sort((a, b) => a[0].localeCompare(b[0]));
+        for (const [key, value] of entries) {
+            if ((0, EventModifierUtil_1.isKeyCustomProperty)(key)) {
+                propertyCount++;
+                if (propertyCount > EventSpecContstants_1.MAX_CUSTOM_EVENT_FIELDS) {
+                    this.logger.debug(`enforcePropertyLimit(): Dropped ${key} because overall ` +
+                        `property limit (${EventSpecContstants_1.MAX_CUSTOM_EVENT_FIELDS}) is reached!`);
+                    droppedCustomProperties = true;
+                    continue;
+                }
+            }
+            result.push([key, value]);
+        }
+        if (droppedCustomProperties) {
+            result.push([
+                "dt.support.api.has_dropped_custom_properties",
+                true,
+            ]);
+        }
+        return result;
+    }
 }
 exports.ModifyEventValidation = ModifyEventValidation;