@fluidframework/app-insights-logger 2.0.0-dev.7.3.0.210328 → 2.0.0-rc.1.0.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @fluid-internal/app-insights-logger
 
+## 2.0.0-rc.1.0.0
+
+### Major Changes
+
+-   @fluid-experimental/app-insights-logger package renamed ([#18817](https://github.com/microsoft/FluidFramework/issues/18817)) [d1f584108b](https://github.com/microsoft/FluidFramework/commits/d1f584108bb93e73c355456d414d444c3641b7ab)
+
+    The package is now `@fluidframework/app-insights-logger`.
+
+## 2.0.0-internal.8.0.0
+
+Dependency updates only.
+
+## 2.0.0-internal.7.4.0
+
+Dependency updates only.
+
+## 2.0.0-internal.7.3.0
+
+Dependency updates only.
+
 ## 2.0.0-internal.7.2.0
 
 Dependency updates only.

package/README.md

@@ -50,7 +50,7 @@ const appInsightsClient = new ApplicationInsights({
 // Initializes the App Insights client. Without this, logs will not be sent to Azure.
 appInsightsClient.loadAppInsights();
 
-const logger = new FluidAppInsightsLogger(appInsightsClient);
+const logger = new createLogger(appInsightsClient);
 
 // Example of sending an event to app insights using the FluidAppInsightsLogger directly
 logger.send({ category: "mockEvent", eventName: "mockEventName" });

package/api-extractor-esm.json

@@ -0,0 +1,18 @@
+{
+	"$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
+	"extends": "../../../../common/build/build-common/api-extractor-base-esm.json",
+	"messages": {
+		"tsdocMessageReporting": {
+			// These exclusions are needed because of errors coming from @microsoft/applicationinsights-web
+			"tsdoc-escape-right-brace": {
+				"logLevel": "none"
+			},
+			"tsdoc-malformed-inline-tag": {
+				"logLevel": "none"
+			},
+			"tsdoc-undefined-tag": {
+				"logLevel": "none"
+			}
+		}
+	}
+}

package/api-extractor-lint.json

@@ -0,0 +1,4 @@
+{
+	"$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
+	"extends": "../../../../common/build/build-common/api-extractor-lint.json"
+}

package/api-extractor.json

@@ -1,7 +1,6 @@
 {
 	"$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
-	"extends": "@fluidframework/build-common/api-extractor-base.json",
-
+	"extends": "../../../../common/build/build-common/api-extractor-base.json",
 	"messages": {
 		// The following overrides are workarounds for API-Extractor incorrectly running analysis on our application
 		// insights dependency.

package/api-report/app-insights-logger.api.md

@@ -5,22 +5,18 @@
 ```ts
 
 import { ApplicationInsights } from '@microsoft/applicationinsights-web';
-import { ITelemetryBaseEvent } from '@fluidframework/core-interfaces';
 import { ITelemetryBaseLogger } from '@fluidframework/core-interfaces';
 import { TelemetryEventCategory } from '@fluidframework/telemetry-utils';
 
-// @public
+// @beta
 export interface CategoryFilter {
     categories: TelemetryEventCategory[];
 }
 
-// @public @sealed
-export class FluidAppInsightsLogger implements ITelemetryBaseLogger {
-    constructor(client: ApplicationInsights, config?: FluidAppInsightsLoggerConfig);
-    send(event: ITelemetryBaseEvent): void;
-}
+// @beta
+export function createLogger(client: ApplicationInsights, config?: FluidAppInsightsLoggerConfig): ITelemetryBaseLogger;
 
-// @public
+// @beta
 export interface FluidAppInsightsLoggerConfig {
     filtering: {
         mode: "inclusive" | "exclusive";
@@ -28,7 +24,7 @@ export interface FluidAppInsightsLoggerConfig {
     };
 }
 
-// @public
+// @beta
 export interface NamespaceFilter {
     namespacePattern: string;
     namespacePatternExceptions?: Set<string>;
@@ -36,7 +32,7 @@ export interface NamespaceFilter {
 
 export { TelemetryEventCategory }
 
-// @public
+// @beta
 export type TelemetryFilter = CategoryFilter | NamespaceFilter | (CategoryFilter & NamespaceFilter);
 
 ```

package/dist/app-insights-logger-alpha.d.ts

@@ -0,0 +1,130 @@
+/**
+ * This package provides a telemetry logger that will route typical Fluid telemetry to Azure App Insights.
+ * {@link https://learn.microsoft.com/en-us/azure/azure-monitor/app/app-insights-overview?tabs=net|Azure App Insights}
+ * @packageDocumentation
+ */
+
+import { ApplicationInsights } from '@microsoft/applicationinsights-web';
+import { ITelemetryBaseLogger } from '@fluidframework/core-interfaces';
+import { TelemetryEventCategory } from '@fluidframework/telemetry-utils';
+
+/**
+ * A filter used to match against the category of a telemetry event
+ * @beta
+ */
+export declare interface CategoryFilter {
+    /**
+     * The categories of telemetry events that this filter applies to
+     */
+    categories: TelemetryEventCategory[];
+}
+
+/**
+ * Creates an {@link @fluidframework/core-interfaces#ITelemetryBaseLogger | ITelemetryBaseLogger}
+ * that routes Fluid telemetry events to Azure App Insights using the App Insights trackEvent API.
+ *
+ * The provided ApplicationInsights instance MUST be initialized with client.loadAppInsights(),
+ * or else logging will not occur.
+ *
+ * @beta
+ */
+export declare function createLogger(client: ApplicationInsights, config?: FluidAppInsightsLoggerConfig): ITelemetryBaseLogger;
+
+/**
+ * The configuration object for creating the logger via {@link createLogger}.
+ * @beta
+ */
+export declare interface FluidAppInsightsLoggerConfig {
+    /**
+     * This Configuration defines how filtering will be applied to Fluid telemetry events flowing through the logger.
+     * This determines which events will be sent to Azure App Insights.
+     */
+    filtering: {
+        /**
+         * Determines whether all telemetry events are sent or not sent by default and whether filters will exclude matching telemetry events or include them.
+         *
+         * "inclusive" mode means all logs are NOT SENT by default and only the events that match at least one or more specified filters WILL be sent (included).
+         *
+         * "exclusive" mode means all logs ARE SENT by default and only the events that match at least one or more specified filters WILL NOT be sent (excluded).
+         */
+        mode: "inclusive" | "exclusive";
+        /**
+         * Controls the filtering of log events.
+         *
+         * @remarks Leaving this undefined will be treated as an empty array.
+         *
+         * In order for the filters to be valid they must meet the following conditions:
+         *
+         * 1. There must not be any two filters with the same `namespacePattern`.
+         *
+         * 2. All {@link NamespaceFilter} must not have any defined `namespacePatternException` that is not a child of the parent `namespacePattern`
+         */
+        filters?: TelemetryFilter[];
+    };
+}
+
+/**
+ * A filter used to match against the namespaces of a telemetry event
+ * @beta
+ */
+export declare interface NamespaceFilter {
+    /**
+     * The namespace pattern to filter telemetry events.
+     *
+     * @remarks This will match namespaces that start with the given string. It is not a Regex pattern.
+     * @example
+     * "perf:latency" will match any namespace starting with "perf:latency"
+     */
+    namespacePattern: string;
+    /**
+     * A list of namespace patterns to explicitly exclude from the filter.
+     *
+     * @example
+     * If you have a namespacePattern of "perf:latency" but want to exclude
+     * events from "perf:latency:ops", you would add "perf:latency:ops" to this list.
+     */
+    namespacePatternExceptions?: Set<string>;
+}
+
+export { TelemetryEventCategory }
+
+/**
+ * Object used with an {@link FluidAppInsightsLoggerConfig}
+ * to define a filter with logic for matching it to telemetry events.
+ * Filters can include either a category, namespace or both types of filters; a valid filter must have at least one defined.
+ * Not definining the `categories` filter array is the same as providing an array with all possible categories.
+ *
+ * Events must satisify the following rules for a telemetry filter:
+ *
+ * 1. The event must match the requirements of the most specific relevant filter to it. This takes precedence over a more generic filter.
+ * The less categories and longer the namespace within a filter, the more specific it is. Definining no categories is equivalant to defining all categories.
+ *
+ * 2. If a {@link TelemetryFilter} specifies both `categories` and a `namespace`, the event must match both.
+ *
+ * 3. If only `categories` or a `namespace` is provided, the event should just match the with whatever was defined.
+ *
+ * 4. If a `namespace` pattern exception is specified in the {@link TelemetryFilter}, the event should not match the exception pattern.
+ * @example
+ * With the following configuration, an event `{ namespace: "A.B.C", categories: ["generic"] }` will not be sent despite matching the first, less specific filter because it did not match the second filter which was the most relevant and specific
+ * ```
+ * const logger = new FluidAppInsightsLogger(appInsightsClient, {
+ *			filtering: {
+ *				mode: "inclusive",
+ *				filters: [
+ *					{
+ *						namespacePattern: "A:B",
+ *						categories: ["generic", "error"],
+ *					},
+ *					{
+ *						namespacePattern: "A:B:C",
+ *						categories: ["error"],
+ *					},
+ *				],
+ *			},
+ *		});
+ * ```
+ * @beta
+ */
+export declare type TelemetryFilter = CategoryFilter | NamespaceFilter | (CategoryFilter & NamespaceFilter);
+
+export { }

package/dist/app-insights-logger-beta.d.ts

@@ -0,0 +1,130 @@
+/**
+ * This package provides a telemetry logger that will route typical Fluid telemetry to Azure App Insights.
+ * {@link https://learn.microsoft.com/en-us/azure/azure-monitor/app/app-insights-overview?tabs=net|Azure App Insights}
+ * @packageDocumentation
+ */
+
+import { ApplicationInsights } from '@microsoft/applicationinsights-web';
+import { ITelemetryBaseLogger } from '@fluidframework/core-interfaces';
+import { TelemetryEventCategory } from '@fluidframework/telemetry-utils';
+
+/**
+ * A filter used to match against the category of a telemetry event
+ * @beta
+ */
+export declare interface CategoryFilter {
+    /**
+     * The categories of telemetry events that this filter applies to
+     */
+    categories: TelemetryEventCategory[];
+}
+
+/**
+ * Creates an {@link @fluidframework/core-interfaces#ITelemetryBaseLogger | ITelemetryBaseLogger}
+ * that routes Fluid telemetry events to Azure App Insights using the App Insights trackEvent API.
+ *
+ * The provided ApplicationInsights instance MUST be initialized with client.loadAppInsights(),
+ * or else logging will not occur.
+ *
+ * @beta
+ */
+export declare function createLogger(client: ApplicationInsights, config?: FluidAppInsightsLoggerConfig): ITelemetryBaseLogger;
+
+/**
+ * The configuration object for creating the logger via {@link createLogger}.
+ * @beta
+ */
+export declare interface FluidAppInsightsLoggerConfig {
+    /**
+     * This Configuration defines how filtering will be applied to Fluid telemetry events flowing through the logger.
+     * This determines which events will be sent to Azure App Insights.
+     */
+    filtering: {
+        /**
+         * Determines whether all telemetry events are sent or not sent by default and whether filters will exclude matching telemetry events or include them.
+         *
+         * "inclusive" mode means all logs are NOT SENT by default and only the events that match at least one or more specified filters WILL be sent (included).
+         *
+         * "exclusive" mode means all logs ARE SENT by default and only the events that match at least one or more specified filters WILL NOT be sent (excluded).
+         */
+        mode: "inclusive" | "exclusive";
+        /**
+         * Controls the filtering of log events.
+         *
+         * @remarks Leaving this undefined will be treated as an empty array.
+         *
+         * In order for the filters to be valid they must meet the following conditions:
+         *
+         * 1. There must not be any two filters with the same `namespacePattern`.
+         *
+         * 2. All {@link NamespaceFilter} must not have any defined `namespacePatternException` that is not a child of the parent `namespacePattern`
+         */
+        filters?: TelemetryFilter[];
+    };
+}
+
+/**
+ * A filter used to match against the namespaces of a telemetry event
+ * @beta
+ */
+export declare interface NamespaceFilter {
+    /**
+     * The namespace pattern to filter telemetry events.
+     *
+     * @remarks This will match namespaces that start with the given string. It is not a Regex pattern.
+     * @example
+     * "perf:latency" will match any namespace starting with "perf:latency"
+     */
+    namespacePattern: string;
+    /**
+     * A list of namespace patterns to explicitly exclude from the filter.
+     *
+     * @example
+     * If you have a namespacePattern of "perf:latency" but want to exclude
+     * events from "perf:latency:ops", you would add "perf:latency:ops" to this list.
+     */
+    namespacePatternExceptions?: Set<string>;
+}
+
+export { TelemetryEventCategory }
+
+/**
+ * Object used with an {@link FluidAppInsightsLoggerConfig}
+ * to define a filter with logic for matching it to telemetry events.
+ * Filters can include either a category, namespace or both types of filters; a valid filter must have at least one defined.
+ * Not definining the `categories` filter array is the same as providing an array with all possible categories.
+ *
+ * Events must satisify the following rules for a telemetry filter:
+ *
+ * 1. The event must match the requirements of the most specific relevant filter to it. This takes precedence over a more generic filter.
+ * The less categories and longer the namespace within a filter, the more specific it is. Definining no categories is equivalant to defining all categories.
+ *
+ * 2. If a {@link TelemetryFilter} specifies both `categories` and a `namespace`, the event must match both.
+ *
+ * 3. If only `categories` or a `namespace` is provided, the event should just match the with whatever was defined.
+ *
+ * 4. If a `namespace` pattern exception is specified in the {@link TelemetryFilter}, the event should not match the exception pattern.
+ * @example
+ * With the following configuration, an event `{ namespace: "A.B.C", categories: ["generic"] }` will not be sent despite matching the first, less specific filter because it did not match the second filter which was the most relevant and specific
+ * ```
+ * const logger = new FluidAppInsightsLogger(appInsightsClient, {
+ *			filtering: {
+ *				mode: "inclusive",
+ *				filters: [
+ *					{
+ *						namespacePattern: "A:B",
+ *						categories: ["generic", "error"],
+ *					},
+ *					{
+ *						namespacePattern: "A:B:C",
+ *						categories: ["error"],
+ *					},
+ *				],
+ *			},
+ *		});
+ * ```
+ * @beta
+ */
+export declare type TelemetryFilter = CategoryFilter | NamespaceFilter | (CategoryFilter & NamespaceFilter);
+
+export { }

package/dist/app-insights-logger-public.d.ts

@@ -0,0 +1,22 @@
+/**
+ * This package provides a telemetry logger that will route typical Fluid telemetry to Azure App Insights.
+ * {@link https://learn.microsoft.com/en-us/azure/azure-monitor/app/app-insights-overview?tabs=net|Azure App Insights}
+ * @packageDocumentation
+ */
+
+import { ApplicationInsights } from '@microsoft/applicationinsights-web';
+import { ITelemetryBaseLogger } from '@fluidframework/core-interfaces';
+import { TelemetryEventCategory } from '@fluidframework/telemetry-utils';
+
+/* Excluded from this release type: CategoryFilter */
+
+/* Excluded from this release type: createLogger */
+
+/* Excluded from this release type: FluidAppInsightsLoggerConfig */
+
+/* Excluded from this release type: NamespaceFilter */
+export { TelemetryEventCategory }
+
+/* Excluded from this release type: TelemetryFilter */
+
+export { }

package/dist/app-insights-logger-untrimmed.d.ts

@@ -0,0 +1,130 @@
+/**
+ * This package provides a telemetry logger that will route typical Fluid telemetry to Azure App Insights.
+ * {@link https://learn.microsoft.com/en-us/azure/azure-monitor/app/app-insights-overview?tabs=net|Azure App Insights}
+ * @packageDocumentation
+ */
+
+import { ApplicationInsights } from '@microsoft/applicationinsights-web';
+import { ITelemetryBaseLogger } from '@fluidframework/core-interfaces';
+import { TelemetryEventCategory } from '@fluidframework/telemetry-utils';
+
+/**
+ * A filter used to match against the category of a telemetry event
+ * @beta
+ */
+export declare interface CategoryFilter {
+    /**
+     * The categories of telemetry events that this filter applies to
+     */
+    categories: TelemetryEventCategory[];
+}
+
+/**
+ * Creates an {@link @fluidframework/core-interfaces#ITelemetryBaseLogger | ITelemetryBaseLogger}
+ * that routes Fluid telemetry events to Azure App Insights using the App Insights trackEvent API.
+ *
+ * The provided ApplicationInsights instance MUST be initialized with client.loadAppInsights(),
+ * or else logging will not occur.
+ *
+ * @beta
+ */
+export declare function createLogger(client: ApplicationInsights, config?: FluidAppInsightsLoggerConfig): ITelemetryBaseLogger;
+
+/**
+ * The configuration object for creating the logger via {@link createLogger}.
+ * @beta
+ */
+export declare interface FluidAppInsightsLoggerConfig {
+    /**
+     * This Configuration defines how filtering will be applied to Fluid telemetry events flowing through the logger.
+     * This determines which events will be sent to Azure App Insights.
+     */
+    filtering: {
+        /**
+         * Determines whether all telemetry events are sent or not sent by default and whether filters will exclude matching telemetry events or include them.
+         *
+         * "inclusive" mode means all logs are NOT SENT by default and only the events that match at least one or more specified filters WILL be sent (included).
+         *
+         * "exclusive" mode means all logs ARE SENT by default and only the events that match at least one or more specified filters WILL NOT be sent (excluded).
+         */
+        mode: "inclusive" | "exclusive";
+        /**
+         * Controls the filtering of log events.
+         *
+         * @remarks Leaving this undefined will be treated as an empty array.
+         *
+         * In order for the filters to be valid they must meet the following conditions:
+         *
+         * 1. There must not be any two filters with the same `namespacePattern`.
+         *
+         * 2. All {@link NamespaceFilter} must not have any defined `namespacePatternException` that is not a child of the parent `namespacePattern`
+         */
+        filters?: TelemetryFilter[];
+    };
+}
+
+/**
+ * A filter used to match against the namespaces of a telemetry event
+ * @beta
+ */
+export declare interface NamespaceFilter {
+    /**
+     * The namespace pattern to filter telemetry events.
+     *
+     * @remarks This will match namespaces that start with the given string. It is not a Regex pattern.
+     * @example
+     * "perf:latency" will match any namespace starting with "perf:latency"
+     */
+    namespacePattern: string;
+    /**
+     * A list of namespace patterns to explicitly exclude from the filter.
+     *
+     * @example
+     * If you have a namespacePattern of "perf:latency" but want to exclude
+     * events from "perf:latency:ops", you would add "perf:latency:ops" to this list.
+     */
+    namespacePatternExceptions?: Set<string>;
+}
+
+export { TelemetryEventCategory }
+
+/**
+ * Object used with an {@link FluidAppInsightsLoggerConfig}
+ * to define a filter with logic for matching it to telemetry events.
+ * Filters can include either a category, namespace or both types of filters; a valid filter must have at least one defined.
+ * Not definining the `categories` filter array is the same as providing an array with all possible categories.
+ *
+ * Events must satisify the following rules for a telemetry filter:
+ *
+ * 1. The event must match the requirements of the most specific relevant filter to it. This takes precedence over a more generic filter.
+ * The less categories and longer the namespace within a filter, the more specific it is. Definining no categories is equivalant to defining all categories.
+ *
+ * 2. If a {@link TelemetryFilter} specifies both `categories` and a `namespace`, the event must match both.
+ *
+ * 3. If only `categories` or a `namespace` is provided, the event should just match the with whatever was defined.
+ *
+ * 4. If a `namespace` pattern exception is specified in the {@link TelemetryFilter}, the event should not match the exception pattern.
+ * @example
+ * With the following configuration, an event `{ namespace: "A.B.C", categories: ["generic"] }` will not be sent despite matching the first, less specific filter because it did not match the second filter which was the most relevant and specific
+ * ```
+ * const logger = new FluidAppInsightsLogger(appInsightsClient, {
+ *			filtering: {
+ *				mode: "inclusive",
+ *				filters: [
+ *					{
+ *						namespacePattern: "A:B",
+ *						categories: ["generic", "error"],
+ *					},
+ *					{
+ *						namespacePattern: "A:B:C",
+ *						categories: ["error"],
+ *					},
+ *				],
+ *			},
+ *		});
+ * ```
+ * @beta
+ */
+export declare type TelemetryFilter = CategoryFilter | NamespaceFilter | (CategoryFilter & NamespaceFilter);
+
+export { }

package/dist/fluidAppInsightsLogger.d.ts

@@ -3,12 +3,11 @@
  * Licensed under the MIT License.
  */
 import { type ApplicationInsights } from "@microsoft/applicationinsights-web";
-import { type ITelemetryBaseEvent, type ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
+import { type ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { type TelemetryEventCategory } from "@fluidframework/telemetry-utils";
 /**
- * The configuration object for the {@link FluidAppInsightsLogger}
- *
- * @public
+ * The configuration object for creating the logger via {@link createLogger}.
+ * @beta
  */
 export interface FluidAppInsightsLoggerConfig {
     /**
@@ -40,8 +39,7 @@ export interface FluidAppInsightsLoggerConfig {
 }
 /**
  * A filter used to match against the category of a telemetry event
- *
- * @public
+ * @beta
  */
 export interface CategoryFilter {
     /**
@@ -51,8 +49,7 @@ export interface CategoryFilter {
 }
 /**
  * A filter used to match against the namespaces of a telemetry event
- *
- * @public
+ * @beta
  */
 export interface NamespaceFilter {
     /**
@@ -88,9 +85,6 @@ export interface NamespaceFilter {
  * 3. If only `categories` or a `namespace` is provided, the event should just match the with whatever was defined.
  *
  * 4. If a `namespace` pattern exception is specified in the {@link TelemetryFilter}, the event should not match the exception pattern.
- *
- * @public
- *
  * @example
  * With the following configuration, an event `{ namespace: "A.B.C", categories: ["generic"] }` will not be sent despite matching the first, less specific filter because it did not match the second filter which was the most relevant and specific
  * ```
@@ -110,55 +104,17 @@ export interface NamespaceFilter {
  *			},
  *		});
  * ```
+ * @beta
  */
 export type TelemetryFilter = CategoryFilter | NamespaceFilter | (CategoryFilter & NamespaceFilter);
 /**
- * An implementation of {@link @fluidframework/core-interfaces#ITelemetryBaseLogger | ITelemetryBaseLogger}
+ * Creates an {@link @fluidframework/core-interfaces#ITelemetryBaseLogger | ITelemetryBaseLogger}
  * that routes Fluid telemetry events to Azure App Insights using the App Insights trackEvent API.
- * The provided ApplicationInsights instance MUST be initialized with client.loadAppInsights()
+ *
+ * The provided ApplicationInsights instance MUST be initialized with client.loadAppInsights(),
  * or else logging will not occur.
  *
- * @sealed
- * @public
+ * @beta
  */
-export declare class FluidAppInsightsLogger implements ITelemetryBaseLogger {
-    /**
-     * The Azure ApplicationInsights client utilized by this logger.
-     * The ApplicationInsights instance MUST be initialized with client.loadAppInsights()
-     * or else logging will not occur.
-     */
-    private readonly baseLoggingClient;
-    private readonly config;
-    constructor(client: ApplicationInsights, config?: FluidAppInsightsLoggerConfig);
-    /**
-     * Routes Fluid telemetry events to the trackEvent App Insights API.
-     * This method also uses the provided {@link FluidAppInsightsLoggerConfig} to
-     * determine whether an event should be sent or not.
-     */
-    send(event: ITelemetryBaseEvent): void;
-    private shouldSendEvent;
-    /**
-     * Checks if a given telemetry event conforms to any of the provided {@link TelemetryFilter} rules.
-     *
-     * 1. The event must match the requirements of the most specific relevant filter to it. This takes precedence over a more generic filter.
-     * The less categories and longer the namespace within a filter, the more specific it is. Definining no categories is equivalant to defining all categories.
-     *
-     * 2. If a {@link TelemetryFilter} specifies both `categories` and a `namespace`, the event must match both.
-     *
-     * 3. If only `categories` or a `namespace` is provided, the event should match either one of them.
-     *
-     * 4. If a `namespace` pattern exception is specified in the {@link TelemetryFilter}, the event should not match the exception pattern.
-     *
-     * @param event - The telemetry event to check against the filters.
-     *
-     * @returns `true` if the event matches any filter, otherwise `false`.
-     */
-    private doesEventMatchFilter;
-    /**
-     * Checks an array of telemetry filters for any issues, merges redundant filters, and returns a fully validated array.
-     *
-     * @throws An Error if there are two filters with duplicate namespace patterns or a filter with a pattern exception that is not a child of the parent pattern.
-     */
-    private validateFilters;
-}
+export declare function createLogger(client: ApplicationInsights, config?: FluidAppInsightsLoggerConfig): ITelemetryBaseLogger;
 //# sourceMappingURL=fluidAppInsightsLogger.d.ts.map

package/dist/fluidAppInsightsLogger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fluidAppInsightsLogger.d.ts","sourceRoot":"","sources":["../src/fluidAppInsightsLogger.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAC9E,OAAO,EACN,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAE9E;;;;GAIG;AACH,MAAM,WAAW,4BAA4B;IAC5C;;;OAGG;IACH,SAAS,EAAE;QACV;;;;;;WAMG;QACH,IAAI,EAAE,WAAW,GAAG,WAAW,CAAC;QAChC;;;;;;;;;;WAUG;QACH,OAAO,CAAC,EAAE,eAAe,EAAE,CAAC;KAC5B,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC9B;;OAEG;IACH,UAAU,EAAE,sBAAsB,EAAE,CAAC;CACrC;AAED;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC/B;;;;;;OAMG;IACH,gBAAgB,EAAE,MAAM,CAAC;IACzB;;;;;;OAMG;IACH,0BAA0B,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACzC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,MAAM,eAAe,GAAG,cAAc,GAAG,eAAe,GAAG,CAAC,cAAc,GAAG,eAAe,CAAC,CAAC;AAEpG;;;;;;;;GAQG;AACH,qBAAa,sBAAuB,YAAW,oBAAoB;IAClE;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAsB;IACxD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA+B;gBACnC,MAAM,EAAE,mBAAmB,EAAE,MAAM,CAAC,EAAE,4BAA4B;IA6BrF;;;;OAIG;IACI,IAAI,CAAC,KAAK,EAAE,mBAAmB,GAAG,IAAI;IAS7C,OAAO,CAAC,eAAe;IAYvB;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,oBAAoB;IA+D5B;;;;OAIG;IACH,OAAO,CAAC,eAAe;CA8BvB"}
+{"version":3,"file":"fluidAppInsightsLogger.d.ts","sourceRoot":"","sources":["../src/fluidAppInsightsLogger.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAC9E,OAAO,EAEN,KAAK,oBAAoB,EACzB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,KAAK,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAE9E;;;GAGG;AACH,MAAM,WAAW,4BAA4B;IAC5C;;;OAGG;IACH,SAAS,EAAE;QACV;;;;;;WAMG;QACH,IAAI,EAAE,WAAW,GAAG,WAAW,CAAC;QAChC;;;;;;;;;;WAUG;QACH,OAAO,CAAC,EAAE,eAAe,EAAE,CAAC;KAC5B,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC9B;;OAEG;IACH,UAAU,EAAE,sBAAsB,EAAE,CAAC;CACrC;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC/B;;;;;;OAMG;IACH,gBAAgB,EAAE,MAAM,CAAC;IACzB;;;;;;OAMG;IACH,0BAA0B,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACzC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,MAAM,eAAe,GAAG,cAAc,GAAG,eAAe,GAAG,CAAC,cAAc,GAAG,eAAe,CAAC,CAAC;AA6LpG;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC3B,MAAM,EAAE,mBAAmB,EAC3B,MAAM,CAAC,EAAE,4BAA4B,GACnC,oBAAoB,CAEtB"}