@microsoft/applicationinsights-core-js 3.0.0-beta.2303-11 → 3.0.0-beta.2304-07

package/types/JavaScriptSDK.Interfaces/IAppInsightsCore.d.ts

@@ -1,171 +0,0 @@
-import { ITelemetryItem } from "./ITelemetryItem";
-import { IChannelControls } from "./IChannelControls";
-import { IPlugin, ITelemetryPlugin } from "./ITelemetryPlugin";
-import { IConfiguration } from "./IConfiguration";
-import { INotificationManager } from "./INotificationManager";
-import { INotificationListener } from "./INotificationListener";
-import { IDiagnosticLogger } from "./IDiagnosticLogger";
-import { IProcessTelemetryContext } from "./IProcessTelemetryContext";
-import { IPerfManagerProvider } from "./IPerfManager";
-import { ICookieMgr } from "./ICookieMgr";
-import { ITelemetryInitializerHandler, TelemetryInitializerFunction } from "./ITelemetryInitializers";
-import { ITelemetryUnloadState } from "./ITelemetryUnloadState";
-import { UnloadHandler } from "../JavaScriptSDK/UnloadHandlerContainer";
-import { SendRequestReason } from "../JavaScriptSDK.Enums/SendRequestReason";
-import { IDistributedTraceContext } from "./IDistributedTraceContext";
-import { ILegacyUnloadHook, IUnloadHook } from "./IUnloadHook";
-import { WatcherFunction } from "../Config/IDynamicWatcher";
-import { ITimerHandler } from "@nevware21/ts-utils";
-export interface ILoadedPlugin<T extends IPlugin> {
-    plugin: T;
-    /**
-     * Identifies whether the plugin is enabled and can process events. This is slightly different from isInitialized as the plugin may be initialized but disabled
-     * via the setEnabled() or it may be a shared plugin which has had it's teardown function called from another instance..
-     * @returns boolean = true if the plugin is in a state where it is operational.
-     */
-    isEnabled: () => boolean;
-    /**
-     * You can optionally enable / disable a plugin from processing events.
-     * Setting enabled to true will not necessarily cause the `isEnabled()` to also return true
-     * as the plugin must also have been successfully initialized and not had it's `teardown` method called
-     * (unless it's also been re-initialized)
-     */
-    setEnabled: (isEnabled: boolean) => void;
-    remove: (isAsync?: boolean, removeCb?: (removed?: boolean) => void) => void;
-}
-export interface IAppInsightsCore<CfgType extends IConfiguration = IConfiguration> extends IPerfManagerProvider {
-    readonly config: CfgType;
-    /**
-     * The current logger instance for this instance.
-     */
-    readonly logger: IDiagnosticLogger;
-    /**
-     * An array of the installed plugins that provide a version
-     */
-    readonly pluginVersionStringArr: string[];
-    /**
-     * The formatted string of the installed plugins that contain a version number
-     */
-    readonly pluginVersionString: string;
-    /**
-     * Returns a value that indicates whether the instance has already been previously initialized.
-     */
-    isInitialized?: () => boolean;
-    initialize(config: CfgType, extensions: IPlugin[], logger?: IDiagnosticLogger, notificationManager?: INotificationManager): void;
-    getChannels(): IChannelControls[];
-    track(telemetryItem: ITelemetryItem): void;
-    /**
-     * Get the current notification manager
-     */
-    getNotifyMgr(): INotificationManager;
-    /**
-     * Get the current cookie manager for this instance
-     */
-    getCookieMgr(): ICookieMgr;
-    /**
-     * Set the current cookie manager for this instance
-     * @param cookieMgr - The manager, if set to null/undefined will cause the default to be created
-     */
-    setCookieMgr(cookieMgr: ICookieMgr): void;
-    /**
-     * Adds a notification listener. The SDK calls methods on the listener when an appropriate notification is raised.
-     * The added plugins must raise notifications. If the plugins do not implement the notifications, then no methods will be
-     * called.
-     * @param listener - An INotificationListener object.
-     */
-    addNotificationListener?(listener: INotificationListener): void;
-    /**
-     * Removes all instances of the listener.
-     * @param listener - INotificationListener to remove.
-     */
-    removeNotificationListener?(listener: INotificationListener): void;
-    /**
-     * Add a telemetry processor to decorate or drop telemetry events.
-     * @param telemetryInitializer - The Telemetry Initializer function
-     * @returns - A ITelemetryInitializerHandler to enable the initializer to be removed
-     */
-    addTelemetryInitializer(telemetryInitializer: TelemetryInitializerFunction): ITelemetryInitializerHandler;
-    pollInternalLogs?(eventName?: string): ITimerHandler;
-    stopPollingInternalLogs?(): void;
-    /**
-     * Return a new instance of the IProcessTelemetryContext for processing events
-     */
-    getProcessTelContext(): IProcessTelemetryContext;
-    /**
-     * Unload and Tear down the SDK and any initialized plugins, after calling this the SDK will be considered
-     * to be un-initialized and non-operational, re-initializing the SDK should only be attempted if the previous
-     * unload call return `true` stating that all plugins reported that they also unloaded, the recommended
-     * approach is to create a new instance and initialize that instance.
-     * This is due to possible unexpected side effects caused by plugins not supporting unload / teardown, unable
-     * to successfully remove any global references or they may just be completing the unload process asynchronously.
-     * @param isAsync - Can the unload be performed asynchronously (default)
-     * @param unloadComplete - An optional callback that will be called once the unload has completed
-     * @param cbTimeout - An optional timeout to wait for any flush operations to complete before proceeding with the unload. Defaults to 5 seconds.
-     */
-    unload(isAsync?: boolean, unloadComplete?: (unloadState: ITelemetryUnloadState) => void, cbTimeout?: number): void;
-    /**
-     * Find and return the (first) plugin with the specified identifier if present
-     * @param pluginIdentifier
-     */
-    getPlugin<T extends IPlugin = IPlugin>(pluginIdentifier: string): ILoadedPlugin<T>;
-    /**
-     * Add a new plugin to the installation
-     * @param plugin - The new plugin to add
-     * @param replaceExisting - should any existing plugin be replaced, default is false
-     * @param doAsync - Should the add be performed asynchronously
-     * @param addCb - [Optional] callback to call after the plugin has been added
-     */
-    addPlugin<T extends IPlugin = ITelemetryPlugin>(plugin: T, replaceExisting?: boolean, doAsync?: boolean, addCb?: (added?: boolean) => void): void;
-    /**
-     * Update the configuration used and broadcast the changes to all loaded plugins, this does NOT support updating, adding or removing
-     * any the plugins (extensions or channels). It will notify each plugin (if supported) that the configuration has changed but it will
-     * not remove or add any new plugins, you need to call addPlugin or getPlugin(identifier).remove();
-     * @param newConfig - The new configuration is apply
-     * @param mergeExisting - Should the new configuration merge with the existing or just replace it. Default is to merge.
-     */
-    updateCfg(newConfig: CfgType, mergeExisting?: boolean): void;
-    /**
-     * Returns the unique event namespace that should be used when registering events
-     */
-    evtNamespace(): string;
-    /**
-     * Add a handler that will be called when the SDK is being unloaded
-     * @param handler - the handler
-     */
-    addUnloadCb(handler: UnloadHandler): void;
-    /**
-     * Add this hook so that it is automatically removed during unloading
-     * @param hooks - The single hook or an array of IInstrumentHook objects
-     */
-    addUnloadHook(hooks: IUnloadHook | IUnloadHook[] | Iterator<IUnloadHook> | ILegacyUnloadHook | ILegacyUnloadHook[] | Iterator<ILegacyUnloadHook>): void;
-    /**
-     * Flush and send any batched / cached data immediately
-     * @param async - send data asynchronously when true (defaults to true)
-     * @param callBack - if specified, notify caller when send is complete, the channel should return true to indicate to the caller that it will be called.
-     * If the caller doesn't return true the caller should assume that it may never be called.
-     * @param sendReason - specify the reason that you are calling "flush" defaults to ManualFlush (1) if not specified
-     * @param cbTimeout - An optional timeout to wait for any flush operations to complete before proceeding with the unload. Defaults to 5 seconds.
-     * @returns - true if the callback will be return after the flush is complete otherwise the caller should assume that any provided callback will never be called
-     */
-    flush(isAsync?: boolean, callBack?: (flushComplete?: boolean) => void, sendReason?: SendRequestReason, cbTimeout?: number): boolean | void;
-    /**
-     * Gets the current distributed trace context for this instance if available
-     * @param createNew - Optional flag to create a new instance if one doesn't currently exist, defaults to true
-     */
-    getTraceCtx(createNew?: boolean): IDistributedTraceContext | null;
-    /**
-     * Sets the current distributed trace context for this instance if available
-     */
-    setTraceCtx(newTraceCtx: IDistributedTraceContext | null | undefined): void;
-    /**
-     * Watches and tracks changes for accesses to the current config, and if the accessed config changes the
-     * handler will be recalled.
-     * @param handler
-     * @returns A watcher handler instance that can be used to remove itself when being unloaded
-     */
-    onCfgChange(handler: WatcherFunction<CfgType>): IUnloadHook;
-    /**
-     * Function used to identify the get w parameter used to identify status bit to some channels
-     */
-    getWParam: () => number;
-}

package/types/JavaScriptSDK.Interfaces/IChannelControls.d.ts

@@ -1,36 +0,0 @@
-import { SendRequestReason } from "../JavaScriptSDK.Enums/SendRequestReason";
-import { IProcessTelemetryUnloadContext } from "./IProcessTelemetryContext";
-import { ITelemetryPlugin } from "./ITelemetryPlugin";
-import { ITelemetryUnloadState } from "./ITelemetryUnloadState";
-/**
- * Provides data transmission capabilities
- */
-export interface IChannelControls extends ITelemetryPlugin {
-    /**
-     * Pause sending data
-     */
-    pause?(): void;
-    /**
-     * Resume sending data
-     */
-    resume?(): void;
-    /**
-     * Tear down the plugin and remove any hooked value, the plugin should be removed so that it is no longer initialized and
-     * therefore could be re-initialized after being torn down. The plugin should ensure that once this has been called any further
-     * processTelemetry calls are ignored and it just calls the processNext() with the provided context.
-     * @param unloadCtx - This is the context that should be used during unloading.
-     * @param unloadState - The details / state of the unload process, it holds details like whether it should be unloaded synchronously or asynchronously and the reason for the unload.
-     * @returns boolean - true if the plugin has or will call processNext(), this for backward compatibility as previously teardown was synchronous and returned nothing.
-     */
-    teardown?: (unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState) => void | boolean;
-    /**
-     * Flush to send data immediately; channel should default to sending data asynchronously
-     * @param async - send data asynchronously when true
-     * @param callBack - if specified, notify caller when send is complete, the channel should return true to indicate to the caller that it will be called.
-     * If the caller doesn't return true the caller should assume that it may never be called.
-     * @param sendReason - specify the reason that you are calling "flush" defaults to ManualFlush (1) if not specified
-     * @returns - true if the callback will be return after the flush is complete otherwise the caller should assume that any provided callback will never be called
-     */
-    flush?(async: boolean, callBack?: (flushComplete?: boolean) => void, sendReason?: SendRequestReason): boolean | void;
-}
-export declare const MinChannelPriorty: number;

package/types/JavaScriptSDK.Interfaces/IChannelControlsHost.d.ts

@@ -1,9 +0,0 @@
-import { IChannelControls } from "./IChannelControls";
-import { IPlugin } from "./ITelemetryPlugin";
-export interface IChannelControlsHost extends IChannelControls {
-    /**
-     * Get and return the named channel instance (if present) from the queues
-     * @param pluginIdentifier - The identifier name of the plugin
-     */
-    getChannel<T extends IPlugin = IPlugin>(pluginIdentifier: string): T;
-}

package/types/JavaScriptSDK.Interfaces/IConfiguration.d.ts

@@ -1,150 +0,0 @@
-import { ITelemetryPlugin } from "./ITelemetryPlugin";
-import { IChannelControls } from "./IChannelControls";
-import { ICookieMgrConfig } from "./ICookieMgr";
-import { INotificationManager } from "./INotificationManager";
-import { IPerfManager } from "./IPerfManager";
-import { IAppInsightsCore } from "./IAppInsightsCore";
-/**
- * Configuration provided to SDK core
- */
-export interface IConfiguration {
-    /**
-     * Instrumentation key of resource. Either this or connectionString must be specified.
-     */
-    instrumentationKey?: string;
-    /**
-     * Connection string of resource. Either this or instrumentationKey must be specified.
-     */
-    connectionString?: string;
-    /**
-     * Polling interval (in ms) for internal logging queue
-     */
-    diagnosticLogInterval?: number;
-    /**
-     * Maximum number of iKey transmitted logging telemetry per page view
-     */
-    maxMessageLimit?: number;
-    /**
-     * Console logging level. All logs with a severity level higher
-     * than the configured level will be printed to console. Otherwise
-     * they are suppressed. ie Level 2 will print both CRITICAL and
-     * WARNING logs to console, level 1 prints only CRITICAL.
-     *
-     * Note: Logs sent as telemetry to instrumentation key will also
-     * be logged to console if their severity meets the configured loggingConsoleLevel
-     *
-     * 0: ALL console logging off
-     * 1: logs to console: severity >= CRITICAL
-     * 2: logs to console: severity >= WARNING
-     */
-    loggingLevelConsole?: number;
-    /**
-     * Telemtry logging level to instrumentation key. All logs with a severity
-     * level higher than the configured level will sent as telemetry data to
-     * the configured instrumentation key.
-     *
-     * 0: ALL iKey logging off
-     * 1: logs to iKey: severity >= CRITICAL
-     * 2: logs to iKey: severity >= WARNING
-     */
-    loggingLevelTelemetry?: number;
-    /**
-     * If enabled, uncaught exceptions will be thrown to help with debugging
-     */
-    enableDebug?: boolean;
-    /**
-     * Endpoint where telemetry data is sent
-     */
-    endpointUrl?: string;
-    /**
-     * Extension configs loaded in SDK
-     */
-    extensionConfig?: {
-        [key: string]: any;
-    };
-    /**
-     * Additional plugins that should be loaded by core at runtime
-     */
-    readonly extensions?: ITelemetryPlugin[];
-    /**
-     * Channel queues that is setup by caller in desired order.
-     * If channels are provided here, core will ignore any channels that are already setup, example if there is a SKU with an initialized channel
-     */
-    readonly channels?: IChannelControls[][];
-    /**
-     * @type {boolean}
-     * Flag that disables the Instrumentation Key validation.
-     */
-    disableInstrumentationKeyValidation?: boolean;
-    /**
-     * [Optional] When enabled this will create local perfEvents based on sections of the code that have been instrumented
-     * to emit perfEvents (via the doPerf()) when this is enabled. This can be used to identify performance issues within
-     * the SDK, the way you are using it or optionally your own instrumented code.
-     * The provided IPerfManager implementation does NOT send any additional telemetry events to the server it will only fire
-     * the new perfEvent() on the INotificationManager which you can listen to.
-     * This also does not use the window.performance API, so it will work in environments where this API is not supported.
-     */
-    enablePerfMgr?: boolean;
-    /**
-     * [Optional] Callback function that will be called to create a the IPerfManager instance when required and ```enablePerfMgr```
-     * is enabled, this enables you to override the default creation of a PerfManager() without needing to ```setPerfMgr()```
-     * after initialization.
-     */
-    createPerfMgr?: (core: IAppInsightsCore, notificationManager: INotificationManager) => IPerfManager;
-    /**
-     * [Optional] Fire every single performance event not just the top level root performance event. Defaults to false.
-     */
-    perfEvtsSendAll?: boolean;
-    /**
-     * [Optional] Identifies the default length used to generate random session and user id's if non currently exists for the user / session.
-     * Defaults to 22, previous default value was 5, if you need to keep the previous maximum length you should set this value to 5.
-     */
-    idLength?: number;
-    /**
-     * @description Custom cookie domain. This is helpful if you want to share Application Insights cookies across subdomains. It
-     * can be set here or as part of the cookieCfg.domain, the cookieCfg takes precedence if both are specified.
-     * @type {string}
-     * @defaultValue ""
-     */
-    cookieDomain?: string;
-    /**
-     * @description Custom cookie path. This is helpful if you want to share Application Insights cookies behind an application
-     * gateway. It can be set here or as part of the cookieCfg.domain, the cookieCfg takes precedence if both are specified.
-     * @type {string}
-     * @defaultValue ""
-     */
-    cookiePath?: string;
-    /**
-     * [Optional] A boolean that indicated whether to disable the use of cookies by the SDK. If true, the SDK will not store or
-     * read any data from cookies. Cookie usage can be re-enabled after initialization via the core.getCookieMgr().enable().
-     */
-    disableCookiesUsage?: boolean;
-    /**
-     * [Optional] A Cookie Manager configuration which includes hooks to allow interception of the get, set and delete cookie
-     * operations. If this configuration is specified any specified enabled and domain properties will take precedence over the
-     * cookieDomain and disableCookiesUsage values.
-     */
-    cookieCfg?: ICookieMgrConfig;
-    /**
-     * [Optional] An array of the page unload events that you would like to be ignored, special note there must be at least one valid unload
-     * event hooked, if you list all or the runtime environment only supports a listed "disabled" event it will still be hooked, if required by the SDK.
-     * Unload events include "beforeunload", "unload", "visibilitychange" (with 'hidden' state) and "pagehide"
-     */
-    disablePageUnloadEvents?: string[];
-    /**
-     * [Optional] An array of page show events that you would like to be ignored, special note there must be at lease one valid show event
-     * hooked, if you list all or the runtime environment only supports a listed (disabled) event it will STILL be hooked, if required by the SDK.
-     * Page Show events include "pageshow" and "visibilitychange" (with 'visible' state)
-     */
-    disablePageShowEvents?: string[];
-    /**
-     * [Optional] A flag for performance optimization to disable attempting to use the Chrome Debug Extension, if disabled and the extension is installed
-     * this will not send any notifications.
-     */
-    disableDbgExt?: boolean;
-    /**
-     * Add "&w=0" parameter to support UA Parsing when web-workers don't have access to Document.
-     * Default is false
-     */
-    enableWParam?: boolean;
-}

package/types/JavaScriptSDK.Interfaces/ICookieMgr.d.ts

@@ -1,97 +0,0 @@
-import { ITelemetryUpdateState } from "./ITelemetryUpdateState";
-export interface ICookieMgr {
-    /**
-     * Enable or Disable the usage of cookies
-     */
-    setEnabled(value: boolean): void;
-    /**
-     * Can the system use cookies, if this returns false then all cookie setting and access functions will return nothing
-     */
-    isEnabled(): boolean;
-    /**
-     * Set the named cookie with the value and optional domain and optional
-     * @param name - The name of the cookie
-     * @param value - The value of the cookie (Must already be encoded)
-     * @param maxAgeSec - [optional] The maximum number of SECONDS that this cookie should survive
-     * @param domain - [optional] The domain to set for the cookie
-     * @param path - [optional] Path to set for the cookie, if not supplied will default to "/"
-     * @returns - True if the cookie was set otherwise false (Because cookie usage is not enabled or available)
-     */
-    set(name: string, value: string, maxAgeSec?: number, domain?: string, path?: string): boolean;
-    /**
-     * Get the value of the named cookie
-     * @param name - The name of the cookie
-     */
-    get(name: string): string;
-    /**
-     * Delete/Remove the named cookie if cookie support is available and enabled.
-     * Note: Not using "delete" as the name because it's a reserved word which would cause issues on older browsers
-     * @param name - The name of the cookie
-     * @param path - [optional] Path to set for the cookie, if not supplied will default to "/"
-     * @returns - True if the cookie was marked for deletion otherwise false (Because cookie usage is not enabled or available)
-     */
-    del(name: string, path?: string): boolean;
-    /**
-     * Purge the cookie from the system if cookie support is available, this function ignores the enabled setting of the manager
-     * so any cookie will be removed.
-     * Note: Not using "delete" as the name because it's a reserved word which would cause issues on older browsers
-     * @param name - The name of the cookie
-     * @param path - [optional] Path to set for the cookie, if not supplied will default to "/"
-     * @returns - True if the cookie was marked for deletion otherwise false (Because cookie usage is not available)
-     */
-    purge(name: string, path?: string): boolean;
-    /**
-     * Optional Callback hook to allow the diagnostic logger to update it's configuration
-     * @param updateState
-     */
-    update?(updateState: ITelemetryUpdateState): void;
-}
-/**
- * Configuration definition for instance based cookie management configuration
- */
-export interface ICookieMgrConfig {
-    /**
-     * Defaults to true, A boolean that indicates whether the use of cookies by the SDK is enabled by the current instance.
-     * If false, the instance of the SDK initialized by this configuration will not store or read any data from cookies
-     */
-    enabled?: boolean;
-    /**
-     * Custom cookie domain. This is helpful if you want to share Application Insights cookies across subdomains.
-     */
-    domain?: string;
-    /**
-     * Specifies the path to use for the cookie, defaults to '/'
-     */
-    path?: string;
-    /**
-     * Specify the cookie name(s) to be ignored, this will cause any matching cookie name to never be read or written.
-     * They may still be explicitly purged or deleted. You do not need to repeat the name in the `blockedCookies`
-     * configuration.(Since v2.8.8)
-     */
-    ignoreCookies?: string[];
-    /**
-     * Specify the cookie name(s) to never be written, this will cause any cookie name to never be created or updated,
-     * they will still be read unless also included in the ignoreCookies and may still be explicitly purged or deleted.
-     * If not provided defaults to the same list provided in ignoreCookies. (Since v2.8.8)
-     */
-    blockedCookies?: string[];
-    /**
-     * Hook function to fetch the named cookie value.
-     * @param name - The name of the cookie
-     */
-    getCookie?: (name: string) => string;
-    /**
-     * Hook function to set the named cookie with the specified value.
-     * @param name - The name of the cookie
-     * @param value - The value to set for the cookie
-     */
-    setCookie?: (name: string, value: string) => void;
-    /**
-     * Hook function to delete the named cookie with the specified value, separated from
-     * setCookie to avoid the need to parse the value to determine whether the cookie is being
-     * added or removed.
-     * @param name - The name of the cookie
-     * @param cookieValue - The value to set to expire the cookie
-     */
-    delCookie?: (name: string, cookieValue: string) => void;
-}

package/types/JavaScriptSDK.Interfaces/IDbgExtension.d.ts

@@ -1,10 +0,0 @@
-import { INotificationListener } from "./INotificationListener";
-export interface IDbgExtension {
-    isEnabled: () => boolean;
-    enable: () => void;
-    disable: () => void;
-    listener: INotificationListener;
-    sendEvt?: (name: string, data: any) => void;
-    debugMsg?: (name: string, data: any) => void;
-    diagLog?: (name: string, data: any) => void;
-}

package/types/JavaScriptSDK.Interfaces/IDiagnosticLogger.d.ts

@@ -1,48 +0,0 @@
-import { LoggingSeverity, _InternalMessageId } from "../JavaScriptSDK.Enums/LoggingEnums";
-import { _InternalLogMessage } from "../JavaScriptSDK/DiagnosticLogger";
-import { ITelemetryUpdateState } from "./ITelemetryUpdateState";
-export interface IDiagnosticLogger {
-    /**
-     * 0: OFF
-     * 1: only critical (default)
-     * 2: critical + info
-     */
-    consoleLoggingLevel: () => number;
-    /**
-     * The internal logging queue
-     */
-    queue: _InternalLogMessage[];
-    /**
-     * This method will throw exceptions in debug mode or attempt to log the error as a console warning.
-     * @param severity - The severity of the log message
-     * @param message - The log message.
-     */
-    throwInternal(severity: LoggingSeverity, msgId: _InternalMessageId, msg: string, properties?: Object, isUserAct?: boolean): void;
-    /**
-     * This will write a warning to the console if possible
-     * @param message - The warning message
-     */
-    warnToConsole(message: string): void;
-    /**
-     * This will write an error to the console if possible.
-     * Provided by the default DiagnosticLogger instance, and internally the SDK will fall back to warnToConsole, however,
-     * direct callers MUST check for its existence on the logger as you can provide your own IDiagnosticLogger instance.
-     * @param message - The error message
-     */
-    errorToConsole?(message: string): void;
-    /**
-     * Resets the internal message count
-     */
-    resetInternalMessageCount(): void;
-    /**
-     * Logs a message to the internal queue.
-     * @param severity - The severity of the log message
-     * @param message - The message to log.
-     */
-    logInternalMessage?(severity: LoggingSeverity, message: _InternalLogMessage): void;
-    /**
-     * Optional Callback hook to allow the diagnostic logger to update it's configuration
-     * @param updateState
-     */
-    update?(updateState: ITelemetryUpdateState): void;
-}

package/types/JavaScriptSDK.Interfaces/IDistributedTraceContext.d.ts

@@ -1,43 +0,0 @@
-export interface IDistributedTraceContext {
-    /**
-     * Returns the current name of the page
-     */
-    getName(): string;
-    /**
-     * Sets the current name of the page
-     * @param pageName
-     */
-    setName(pageName: string): void;
-    /**
-     * Returns the unique identifier for a trace. All requests / spans from the same trace share the same traceId.
-     * Must be read from incoming headers or generated according to the W3C TraceContext specification,
-     * in a hex representation of 16-byte array. A.k.a. trace-id, TraceID or Distributed TraceID
-     */
-    getTraceId(): string;
-    /**
-     * Set the unique identifier for a trace. All requests / spans from the same trace share the same traceId.
-     * Must be conform to the W3C TraceContext specification, in a hex representation of 16-byte array.
-     * A.k.a. trace-id, TraceID or Distributed TraceID https://www.w3.org/TR/trace-context/#trace-id
-     */
-    setTraceId(newValue: string): void;
-    /**
-     * Self-generated 8-bytes identifier of the incoming request. Must be a hex representation of 8-byte array.
-     * Also know as the parentId, used to link requests together
-     */
-    getSpanId(): string;
-    /**
-     * Self-generated 8-bytes identifier of the incoming request. Must be a hex representation of 8-byte array.
-     * Also know as the parentId, used to link requests together
-     * https://www.w3.org/TR/trace-context/#parent-id
-     */
-    setSpanId(newValue: string): void;
-    /**
-     * An integer representation of the W3C TraceContext trace-flags.
-     */
-    getTraceFlags(): number | undefined;
-    /**
-     * https://www.w3.org/TR/trace-context/#trace-flags
-     * @param newValue
-     */
-    setTraceFlags(newValue?: number): void;
-}

package/types/JavaScriptSDK.Interfaces/IInstrumentHooks.d.ts

@@ -1,81 +0,0 @@
-import { IUnloadHook } from "./IUnloadHook";
-/**
- * A callback function that will be called for the wrapped instrumentation function
- * before the original function is executed.
- */
-export type InstrumentorHooksCallback = (funcArgs: IInstrumentCallDetails, ...orgArgs: any[]) => void;
-/**
- * The callbacks to call for the instrumented function, you must provide at least the request and/or response callbacks, both are not required.
- * You must always supply the error callback
- */
-export interface IInstrumentHooksCallbacks {
-    /**
-     * [Optional] Namespace details (same as the namespace used for events), useful for debugging and testing to
-     * identify the source of the instrumented hooks
-     */
-    ns?: string | string[];
-    /**
-     * The hook callback to call before the original function is called
-     */
-    req?: InstrumentorHooksCallback;
-    /**
-     * The hook callback to call after the original function was called
-     */
-    rsp?: InstrumentorHooksCallback;
-    /**
-     * The callback to call if the hook function causes an exception
-     */
-    hkErr?: InstrumentorHooksCallback;
-    /**
-     * The callback to call if the original function causes an exception, even if you
-     * supply a callback the original exception will still be thrown
-     */
-    fnErr?: InstrumentorHooksCallback;
-}
-/**
- * The holder of the specific instance callback
- */
-export interface IInstrumentHook extends IUnloadHook {
-    /** Unique Id for this callback on the hooked method */
-    id: number;
-    /** Holds the callbacks */
-    cbks: IInstrumentHooksCallbacks;
-    /** Remove this hook from the function */
-    rm: () => void;
-}
-export interface IInstrumentHooks {
-    i: number;
-    n: string;
-    f: any;
-    h: IInstrumentHook[];
-}
-export interface IInstrumentCallDetails {
-    name: string;
-    inst: any;
-    /**
-     * This returns an object that the hook function can use to store hook specific
-     * context, it it not shared with any other hook instances and is unique for the
-     * current call.
-     * A hook implementation can use this to pass / share context between different
-     * hook callbacks eg. request/response requst/hookErrors etc.
-     */
-    ctx: () => any;
-    /**
-     * Allows the hook functions to replace the original arguments
-     * @param idx - The argument index (0 based)
-     * @param value - The new value for the argument
-     */
-    set: (idx: number, value: any) => void;
-    /**
-     * The result of the original method, only populated after the original method has returned
-     */
-    rslt?: any;
-    /**
-     * The error (exception) which occurred while executing the original method
-     */
-    err?: Error;
-    /**
-     * The Event object from (window.event) at the start of the original call
-     */
-    evt?: Event;
-}