@microsoft/1ds-post-js 3.2.11 → 4.0.0

package/src/RetryPolicy.ts

@@ -1,46 +0,0 @@
-/**
-* RetryPolicy.ts
-* @author Abhilash Panwar (abpanwar)
-* @copyright Microsoft 2018
-*/
-const RandomizationLowerThreshold = 0.8;
-const RandomizationUpperThreshold = 1.2;
-const BaseBackoff = 3000;
-const MaxBackoff = 600000;
-
-/**
- * Determine if the request should be retried for the given status code.
- * The below expression reads that we should only retry for:
- *      - HttpStatusCodes that are smaller than 300.
- *      - HttpStatusCodes greater or equal to 500 (except for 501-NotImplement
- *        and 505-HttpVersionNotSupport).
- *      - HttpStatusCode 408-RequestTimeout.
- *      - HttpStatusCode 429.
- * This is based on Microsoft.WindowsAzure.Storage.RetryPolicies.ExponentialRetry class
- * @param httpStatusCode - The status code returned for the request.
- * @returns True if request should be retried, false otherwise.
- */
-export function retryPolicyShouldRetryForStatus(httpStatusCode: number): boolean {
-    /* tslint:disable:triple-equals */
-    // Disabling triple-equals rule to avoid httpOverrides from failing because they are returning a string value
-    return !((httpStatusCode >= 300 && httpStatusCode < 500 && httpStatusCode != 408 && httpStatusCode != 429)
-        || (httpStatusCode == 501)
-        || (httpStatusCode == 505));
-    /* tslint:enable:triple-equals */
-}
-
-/**
- * Gets the number of milliseconds to back off before retrying the request. The
- * back off duration is exponentially scaled based on the number of retries already
- * done for the request.
- * @param retriesSoFar - The number of times the request has already been retried.
- * @returns The back off duration for the request before it can be retried.
- */
-export function retryPolicyGetMillisToBackoffForRetry(retriesSoFar: number): number {
-    let waitDuration = 0;
-    let minBackoff = BaseBackoff * RandomizationLowerThreshold;
-    let maxBackoff = BaseBackoff * RandomizationUpperThreshold;
-    let randomBackoff = Math.floor(Math.random() * (maxBackoff - minBackoff)) + minBackoff;
-    waitDuration = Math.pow(2, retriesSoFar) * randomBackoff;
-    return Math.min(waitDuration, MaxBackoff);
-}

package/src/Serializer.ts

@@ -1,487 +0,0 @@
-/**
-* Serializer.ts
-* @author Abhilash Panwar (abpanwar); Hector Hernandez (hectorh); Nev Wylie (newylie)
-* @copyright Microsoft 2018-2020
-*/
-// @skip-file-minify
-
-import dynamicProto from "@microsoft/dynamicproto-js";
-import {
-    EventSendType, FieldValueSanitizerFunc, FieldValueSanitizerType, IEventProperty, IPerfManagerProvider, IValueSanitizer,
-    SendRequestReason, arrIndexOf, doPerf, getCommonSchemaMetaData, getTenantId, isArray, isValueAssigned, objForEachKey, sanitizeProperty,
-    strStartsWith
-} from "@microsoft/1ds-core-js";
-import { IPostTransmissionTelemetryItem } from "./DataModels";
-import { EventBatch } from "./EventBatch";
-import { STR_EMPTY } from "./InternalConstants";
-
-/**
- * Note: This is an optimization for V8-based browsers. When V8 concatenates a string,
- * the strings are only joined logically using a "cons string" or "constructed/concatenated
- * string". These containers keep references to one another and can result in very large
- * memory usage. For example, if a 2MB string is constructed by concatenating 4 bytes
- * together at a time, the memory usage will be ~44MB; so ~22x increase. The strings are
- * only joined together when an operation requiring their joining takes place, such as
- * substr(). This function is called when adding data to this buffer to ensure these
- * types of strings are periodically joined to reduce the memory footprint.
- * Setting to every 20 events as the JSON.stringify() may have joined many strings
- * and calling this too much causes a minor delay while processing.
- */
-const _MAX_STRING_JOINS = 20;
-
-const RequestSizeLimitBytes = 3984588;  // approx 3.8 Mb
-const BeaconRequestSizeLimitBytes = 65000; // approx 64kb (the current Edge, Firefox and Chrome max limit)
-const MaxRecordSize = 2000000; // approx 2 Mb
-const MaxBeaconRecordSize = Math.min(MaxRecordSize, BeaconRequestSizeLimitBytes);
-const metadata = "metadata";
-const f = "f";
-const rCheckDot = /\./;
-
-export interface ISerializedPayload {
-    /**
-     * The collection of iKeys included in this payload
-     */
-    apiKeys: string[];
-
-    /**
-     * Serialized payload blob that needs to be sent.
-     */
-    payloadBlob: string;
-
-    /**
-     * Extra events that would not fit into the serialized blob limit
-     */
-    overflow: EventBatch;
-
-    /**
-     * Events that where dropped because they exceeded the individual limit
-     */
-    sizeExceed: EventBatch[];
-
-    /**
-     * Events that where dropped because they could not be serialized
-     */
-    failedEvts: EventBatch[];
-
-     /**
-     * The batches included in this payload
-     */
-    batches: EventBatch[];
-
-    /**
-     * The number of events in the payload
-     */
-    numEvents: number;
-
-    /**
-     * The retry count for this payload
-     */
-    retryCnt: number;
-
-    /**
-     * Was this payload created during a teardown
-     */
-    isTeardown: boolean;
-
-    /**
-     * Is this payload a synchronous payload
-     */
-    isSync: boolean;
-
-    /**
-     * The payload has been constructed using a reduced payload size for usage with sendBeacon or fetch(with keepAlive) API's
-     */
-    isBeacon: boolean;
-
-    /**
-     * The request event sync type
-     */
-    sendType: EventSendType;
-
-    /**
-     * The reason the payload has is being sent
-     */
-    sendReason?: SendRequestReason;
-}
-
-/**
-* Class to handle serialization of event and request.
-* Currently uses Bond for serialization. Please note that this may be subject to change.
-*/
-export class Serializer {
-
-    constructor(perfManager?: IPerfManagerProvider, valueSanitizer?: IValueSanitizer, stringifyObjects?: boolean, enableCompoundKey?: boolean) {
-        const strData = "data";
-        const strBaseData = "baseData";
-        const strExt = "ext";
-
-        let _checkForCompoundkey = !!enableCompoundKey;
-        let _processSubMetaData = true;
-        let _theSanitizer: IValueSanitizer = valueSanitizer;
-        let _isReservedCache = {};
-
-        dynamicProto(Serializer, this, (_self) => {
-
-            _self.createPayload = (retryCnt: number, isTeardown: boolean, isSync: boolean, isReducedPayload: boolean, sendReason: SendRequestReason, sendType: EventSendType): ISerializedPayload => {
-                return {
-                    apiKeys: [],
-                    payloadBlob: STR_EMPTY,
-                    overflow: null,
-                    sizeExceed: [],
-                    failedEvts: [],
-                    batches: [],
-                    numEvents: 0,
-                    retryCnt: retryCnt,
-                    isTeardown: isTeardown,
-                    isSync: isSync,
-                    isBeacon: isReducedPayload,
-                    sendType: sendType,
-                    sendReason: sendReason
-                };
-            };
-
-            _self.appendPayload = (payload: ISerializedPayload, theBatch: EventBatch, maxEventsPerBatch: number): boolean => {
-                let canAddEvents = payload && theBatch && !payload.overflow;
-                if (canAddEvents) {
-                    doPerf(perfManager, () => "Serializer:appendPayload", () => {
-                        let theEvents = theBatch.events();
-                        let payloadBlob = payload.payloadBlob;
-                        let payloadEvents = payload.numEvents;
-                        let eventsAdded = false;
-                        let sizeExceeded: IPostTransmissionTelemetryItem[] = [];
-                        let failedEvts: IPostTransmissionTelemetryItem[] = [];
-                        let isBeaconPayload = payload.isBeacon;
-                        let requestMaxSize = isBeaconPayload ? BeaconRequestSizeLimitBytes : RequestSizeLimitBytes;
-                        let recordMaxSize = isBeaconPayload ? MaxBeaconRecordSize : MaxRecordSize;
-
-                        let lp = 0;
-                        let joinCount = 0;
-                        while (lp < theEvents.length) {
-                            let theEvent = theEvents[lp];
-                            if (theEvent) {
-                                if (payloadEvents >= maxEventsPerBatch) {
-                                    // Maximum events per payload reached, so don't add any more
-                                    payload.overflow = theBatch.split(lp);
-                                    break;
-                                }
-
-                                let eventBlob = _self.getEventBlob(theEvent);
-                                if (eventBlob && eventBlob.length <= recordMaxSize) {
-                                    // This event will fit into the payload
-                                    let blobLength = eventBlob.length;
-                                    let currentSize = payloadBlob.length;
-                                    if (currentSize + blobLength > requestMaxSize) {
-                                        // Request or batch size exceeded, so don't add any more to the payload
-                                        payload.overflow = theBatch.split(lp);
-                                        break;
-                                    }
-
-                                    if (payloadBlob) {
-                                        payloadBlob += "\n";
-                                    }
-
-                                    payloadBlob += eventBlob;
-
-                                    joinCount ++;
-                                    // v8 memory optimization only
-                                    if (joinCount > _MAX_STRING_JOINS) {
-                                        // this substr() should cause the constructed string to join
-                                        payloadBlob.substr(0, 1);
-                                        joinCount = 0;
-                                    }
-
-                                    eventsAdded = true;
-                                    payloadEvents++;
-                                } else {
-                                    if (eventBlob) {
-                                        // Single event size exceeded so remove from the batch
-                                        sizeExceeded.push(theEvent);
-                                    } else {
-                                        failedEvts.push(theEvent);
-                                    }
-
-                                    // We also need to remove this event from the existing array, otherwise a notification will be sent
-                                    // indicating that it was successfully sent
-                                    theEvents.splice(lp, 1);
-                                    lp--;
-                                }
-                            }
-
-                            lp++;
-                        }
-
-                        if (sizeExceeded && sizeExceeded.length > 0) {
-                            payload.sizeExceed.push(EventBatch.create(theBatch.iKey(), sizeExceeded));
-                            // Remove the exceeded events from the batch
-                        }
-
-                        if (failedEvts && failedEvts.length > 0) {
-                            payload.failedEvts.push(EventBatch.create(theBatch.iKey(), failedEvts));
-                            // Remove the failed events from the batch
-                        }
-
-                        if (eventsAdded) {
-                            payload.batches.push(theBatch);
-                            payload.payloadBlob = payloadBlob;
-                            payload.numEvents = payloadEvents;
-
-                            let apiKey = theBatch.iKey();
-                            if (arrIndexOf(payload.apiKeys, apiKey) === -1) {
-                                payload.apiKeys.push(apiKey);
-                            }
-                        }
-                    }, () => ({ payload: payload, theBatch: { iKey: theBatch.iKey(), evts: theBatch.events() }, max: maxEventsPerBatch }));
-                }
-
-                return canAddEvents;
-            };
-
-            _self.getEventBlob = (eventData: IPostTransmissionTelemetryItem): string => {
-                try {
-                    return doPerf(perfManager, () => "Serializer.getEventBlob", () => {
-                        let serializedEvent = { } as any;
-                        // Adding as dynamic keys for v8 performance
-                        serializedEvent.name = eventData.name;
-                        serializedEvent.time = eventData.time;
-                        serializedEvent.ver = eventData.ver;
-                        serializedEvent.iKey = "o:" + getTenantId(eventData.iKey);
-
-                        // Assigning local var so usage in part b/c don't throw if there is no ext
-                        let serializedExt = {};
-
-                        // Part A
-                        let eventExt = eventData[strExt];
-                        if (eventExt) {
-                            // Only assign ext if the event had one (There are tests covering this use case)
-                            serializedEvent[strExt] = serializedExt;
-                            objForEachKey(eventExt, (key, value) => {
-                                let data = serializedExt[key] = {};
-
-                                // Don't include a metadata callback as we don't currently set metadata Part A fields
-                                _processPathKeys(value, data, "ext." + key, true, null, null, true);
-                            });
-                        }
-
-                        let serializedData: any = serializedEvent[strData] = {};
-                        serializedData.baseType = eventData.baseType;
-
-                        let serializedBaseData = serializedData[strBaseData] = {};
-
-                        // Part B
-                        _processPathKeys(eventData.baseData, serializedBaseData, strBaseData, false, [strBaseData], (pathKeys, name, value) => {
-                            _addJSONPropertyMetaData(serializedExt, pathKeys, name, value);
-                        }, _processSubMetaData);
-
-                        // Part C
-                        _processPathKeys(eventData.data, serializedData, strData, false, [], (pathKeys, name, value) => {
-                            _addJSONPropertyMetaData(serializedExt, pathKeys, name, value);
-                        }, _processSubMetaData);
-
-                        return JSON.stringify(serializedEvent);
-                    }, () => ({ item: eventData }));
-                } catch (e) {
-                    return null;
-                }
-            };
-
-            function _isReservedField(path: string, name: string): boolean {
-                let result = _isReservedCache[path];
-
-                if (result === undefined)  {
-                    if (path.length >= 7) {
-                        // Do not allow the changing of fields located in the ext.metadata or ext.web extension
-                        result = strStartsWith(path, "ext.metadata") || strStartsWith(path, "ext.web");
-                    }
-
-                    _isReservedCache[path] = result;
-                }
-
-                return result;
-            }
-
-            function _processPathKeys(
-                    srcObj: any,
-                    target: { [key: string]: {}},
-                    thePath: string,
-                    checkReserved: boolean,
-                    metadataPathKeys: string[],
-                    metadataCallback: (pathKeys: string[], key: string, value: IEventProperty) => void,
-                    processSubKeys: boolean) {
-
-                objForEachKey(srcObj, (key, srcValue) => {
-                    let prop: IEventProperty = null;
-                    if (srcValue || isValueAssigned(srcValue)) {
-                        let path = thePath;
-                        let name = key;
-
-                        let theMetaPathKeys = metadataPathKeys;
-                        let destObj = target;
-
-                        // Handle keys with embedded '.', like "TestObject.testProperty"
-                        if (_checkForCompoundkey && !checkReserved && rCheckDot.test(key)) {
-                            let subKeys = key.split(".");
-                            let keyLen = subKeys.length;
-                            if (keyLen > 1) {
-                                if (theMetaPathKeys) {
-                                    // Create a copy of the meta path keys so we can add the extra ones
-                                    theMetaPathKeys = theMetaPathKeys.slice();
-                                }
-
-                                for (let lp = 0; lp < keyLen - 1; lp++) {
-                                    let subKey = subKeys[lp];
-                                    // Add/reuse the sub key object
-                                    destObj = destObj[subKey] = destObj[subKey] || {};
-                                    path += "." + subKey;
-                                    if (theMetaPathKeys) {
-                                        theMetaPathKeys.push(subKey);
-                                    }
-                                }
-
-                                name = subKeys[keyLen - 1];
-                            }
-                        }
-
-                        let isReserved = checkReserved && _isReservedField(path, name);
-                        if (!isReserved && _theSanitizer && _theSanitizer.handleField(path, name)) {
-                            prop = _theSanitizer.value(path, name, srcValue, stringifyObjects);
-                        } else {
-                            prop = sanitizeProperty(name, srcValue, stringifyObjects);
-                        }
-
-                        if (prop) {
-                            // Set the value
-                            let newValue: any = prop.value;
-                            destObj[name] = newValue;
-
-                            if (metadataCallback) {
-                                metadataCallback(theMetaPathKeys, name, prop);
-                            }
-
-                            if (processSubKeys && typeof newValue === "object" && !isArray(newValue)) {
-                                let newPath = theMetaPathKeys;
-                                if (newPath) {
-                                    newPath = newPath.slice();
-                                    newPath.push(name);
-                                }
-
-                                // Make sure we process sub objects as well (for value sanitization and metadata)
-                                _processPathKeys(srcValue, newValue, path + "." + name, checkReserved, newPath, metadataCallback, processSubKeys);
-                            }
-                        }
-                    }
-                });
-            }
-        });
-    }
-
-    /**
-     * Create a serializer payload package
-     * @param retryCnt The retry count for the events in this payload
-     * @param isTeardown Is this payload being created as part of a teardown request
-     * @param isSync Should this payload be sent as a synchronous request
-     * @param isReducedPayload Is this payload going to be sent via sendBeacon() API
-     * @param sendReason The reason the payload is being sent
-     * @param sendType Identifies how this payload will be sent
-     */
-    public createPayload(retryCnt: number, isTeardown: boolean, isSync: boolean, isReducedPayload: boolean, sendReason: SendRequestReason, sendType: EventSendType): ISerializedPayload {
-        // @DynamicProtoStub - DO NOT add any code as this will be removed during packaging
-        return null;
-    }
-
-    /**
-     * Append the batched events into the payload
-     * @param payload The serialized payload detail object
-     * @param theBatch The batched events to append to the payload
-     * @param maxEventsPerBatch The maximum number of events to allow in the payload
-     * @returns True if the events from the new batch where attempted to be added to the payload otherwise false
-     */
-    public appendPayload(payload: ISerializedPayload, theBatch: EventBatch, maxEventsPerBatch: number): boolean {
-        // @DynamicProtoStub - DO NOT add any code as this will be removed during packaging
-        return false;
-    }
-
-    /**
-     * Bond serialize the event.
-     * @param eventData - The event that needs to be serialized.
-     * @returns The serialized json event.
-     */
-    public getEventBlob(eventData: IPostTransmissionTelemetryItem): string {
-        // @DynamicProtoStub - DO NOT add any code as this will be removed during packaging
-        return null;
-    }
-
-    /**
-     * Does this field value sanitizer handle this path / field combination
-     * @param path - The field path
-     * @param name - The name of the field
-     */
-    public handleField(path: string, name: string): boolean {
-        // @DynamicProtoStub - DO NOT add any code as this will be removed during packaging
-        return false;
-    }
-
-    /**
-     * Get the field sanitizer for this type of field based on the field type, value kind and/or event property type
-     * @param path - The field path
-     * @param name - The name of the field
-     * @param theType - The type of field
-     * @param theKind - The value kind of the field
-     * @param propType - The property type of the field
-     */
-    public getSanitizer(path: string, name: string, theType: FieldValueSanitizerType, theKind?: number, propType?: number): FieldValueSanitizerFunc | null | undefined {
-        // @DynamicProtoStub - DO NOT add any code as this will be removed during packaging
-        return null;
-    }
-
-}
-
-/**
- * @ignore
- */
-function _addJSONPropertyMetaData(json: { [name: string]: {} }, propKeys: string[], name: string, propertyValue: IEventProperty | null) {
-    if (propertyValue && json) {
-        let encodedTypeValue = getCommonSchemaMetaData(propertyValue.value, propertyValue.kind, propertyValue.propertyType);
-        if (encodedTypeValue > -1) {
-            // Add the root metadata
-            let metaData = json[metadata];
-            if (!metaData) {
-                // Sets the root 'f'
-                metaData = json[metadata] = { f: {} };
-            }
-
-            let metaTarget = metaData[f];
-            if (!metaTarget) {
-                // This can occur if someone has manually added an ext.metadata object
-                // Such as ext.metadata.privLevel and ext.metadata.privTags
-                metaTarget = metaData[f] = {};
-            }
-
-            // Traverse the metadata path and build each object (contains an 'f' key) -- if required
-            if (propKeys) {
-                for (let lp = 0; lp < propKeys.length; lp++) {
-                    let key = propKeys[lp];
-                    if (!metaTarget[key]) {
-                        metaTarget[key] = { f: {} };
-                    }
-
-                    let newTarget = metaTarget[key][f];
-                    if (!newTarget) {
-                        // Not expected, but can occur if the metadata context was pre-created as part of the event
-                        newTarget = metaTarget[key][f] = {};
-                    }
-
-                    metaTarget = newTarget;
-                }
-            }
-
-            metaTarget = metaTarget[name] = { };
-            if (isArray(propertyValue.value)) {
-                metaTarget["a"] = {
-                    t: encodedTypeValue
-                };
-            } else {
-                metaTarget["t"] = encodedTypeValue;
-            }
-        }
-    }
-}

package/src/TimeoutOverrideWrapper.ts

@@ -1,29 +0,0 @@
-/**
-* TimeoutOverrideWrapper.ts
-* @author  Nev Wylie (newylie)
-* @copyright Microsoft 2022
-* Simple internal timeout wrapper
-*/
-
-export type TimeoutSetFunc<T = any> = (callback: (...args: any[]) => void, ms: number, ...args: any[]) => T;
-export type TimeoutClearFunc<T = any> = (timeoutId?: T) => void;
-
-export interface ITimeoutOverrideWrapper<T = any> {
-    set: TimeoutSetFunc<T>;
-    clear: TimeoutClearFunc<T>;
-}
-
-export function defaultSetTimeout<T = any>(callback: (...args: any[]) => void, ms: number, ...args: any[]): T {
-    return setTimeout(callback, ms, args) as any;
-}
-
-export function defaultClearTimeout<T = any>(timeoutId?: T): void {
-    clearTimeout(timeoutId as any);
-}
-
-export function createTimeoutWrapper<T = any>(argSetTimeout?: TimeoutSetFunc<T>, argClearTimeout?: TimeoutClearFunc<T>) {
-    return {
-        set: argSetTimeout || defaultSetTimeout,
-        clear: argClearTimeout || defaultClearTimeout
-    } 
-}

package/src/typings/XDomainRequest.ts

@@ -1,23 +0,0 @@
-// This interface was removed from newer versions of typescript. Restore it for legacy support
-export interface XDomainRequest {
-    timeout: number;
-    onerror: (ev: Event) => any;
-    onload: (ev: Event) => any;
-    onprogress: (ev: any) => any;
-    ontimeout: (ev: Event) => any;
-    responseText: string;
-    contentType: string;
-    open(method: string, url: string): void;
-    create(): XDomainRequest;
-    abort(): void;
-    send(data?: any): void;
-    addEventListener(type: "error", listener: (ev: ErrorEvent) => any, useCapture?: boolean): void;
-    addEventListener(type: "load" | "timeout", listener: (ev: Event) => any, useCapture?: boolean): void;
-    addEventListener(type: "progress", listener: (ev: ProgressEvent) => any, useCapture?: boolean): void;
-    addEventListener(type: string, listener: EventListener, useCapture?: boolean): void;
-}
-
-// export declare var XDomainRequest: {
-//     prototype: IXDomainRequest;
-//     new (): IXDomainRequest;
-// };