@fluidframework/app-insights-logger 2.0.0-dev.7.3.0.210328

package/.eslintrc.js

@@ -0,0 +1,11 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+module.exports = {
+	extends: [require.resolve("@fluidframework/eslint-config-fluid/strict"), "prettier"],
+	parserOptions: {
+		project: ["./tsconfig.json"],
+	},
+};

package/.mocharc.js

@@ -0,0 +1,12 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+"use strict";
+
+const getFluidTestMochaConfig = require("@fluidframework/mocha-test-setup/mocharc-common");
+
+const packageDir = __dirname;
+const config = getFluidTestMochaConfig(packageDir);
+module.exports = config;

package/CHANGELOG.md

@@ -0,0 +1,57 @@
+# @fluid-internal/app-insights-logger
+
+## 2.0.0-internal.7.2.0
+
+Dependency updates only.
+
+## 2.0.0-internal.7.1.0
+
+Dependency updates only.
+
+## 2.0.0-internal.7.0.0
+
+Dependency updates only.
+
+## 2.0.0-internal.6.4.0
+
+Dependency updates only.
+
+## 2.0.0-internal.6.3.0
+
+Dependency updates only.
+
+## 2.0.0-internal.6.2.0
+
+Dependency updates only.
+
+## 2.0.0-internal.6.1.0
+
+Dependency updates only.
+
+## 2.0.0-internal.6.0.0
+
+Dependency updates only.
+
+## 2.0.0-internal.5.4.0
+
+Dependency updates only.
+
+## 2.0.0-internal.5.3.0
+
+Dependency updates only.
+
+## 2.0.0-internal.5.2.0
+
+Dependency updates only.
+
+## 2.0.0-internal.5.1.0
+
+Dependency updates only.
+
+## 2.0.0-internal.5.0.0
+
+Dependency updates only.
+
+## 2.0.0-internal.4.4.0
+
+Dependency updates only.

package/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,155 @@
+# @fluidframework/app-insights-logger
+
+## Overview
+
+This `app-insights-logger` package provides a Fluid telemetry logger that will route Fluid telemetry to Azure App Insights using the `ApplicationInsights.trackEvent` API provided by the [@microsoft/applicationinsights-web](https://www.npmjs.com/package/@microsoft/applicationinsights-web) package. The logger is intended for use by browser based web applications, not NodeJS applications [as stated by the App Insights Web SDK.](https://learn.microsoft.com/en-us/azure/azure-monitor/app/app-insights-overview?tabs=net)
+
+## What is Application Insights?
+
+At a high level, App Insights is an Azure cloud service for aggregating, visualizing, analyzing, and alerting on metrics related to a given “service” or “application”.
+You create an App Insights Instance and then configure your applications to send data to your instance using either Azure provided SDK’s or REST APIs.
+This could be general machine related health being automatically reported to the instance when you install a logging program on your service’s machines or custom metrics that you manually configure your applications to send. Keep in mind this logger is intended for use with browser based web applications, not pure nodeJS.
+In our case, we are sending custom metrics. [Learn more about Azure App Insights with their docs](https://learn.microsoft.com/en-us/azure/azure-monitor/app/app-insights-overview?tabs=net)
+
+<!-- AUTO-GENERATED-CONTENT:START (README_INSTALLATION_SECTION:includeHeading=TRUE&devDependency=FALSE) -->
+
+<!-- prettier-ignore-start -->
+<!-- NOTE: This section is automatically generated using @fluid-tools/markdown-magic. Do not update these generated contents directly. -->
+
+## Installation
+
+To get started, install the package by running the following command:
+
+```bash
+npm i @fluidframework/app-insights-logger
+```
+
+<!-- prettier-ignore-end -->
+
+<!-- AUTO-GENERATED-CONTENT:END -->
+
+## Use case
+
+The primary use case of sending telemetry to Azure App Insights allows users to analyze and store telemetry logs without having to manually setup complex infrastructure.
+Once in App Insights users can leverage Azure's log exploring tools to analyze logs.
+
+## Usage
+
+In order to use this logger, users will first have to initialize an `ApplicationInsights` client from the `@microsoft/applicationinsights-web` package. In most cases, initializing the `ApplicationInsights` client will be just providing your App Insight instances connection string AND calling `.loadAppInsights()` on your client. [Learn more about the App Insights SDK](https://github.com/microsoft/ApplicationInsights-JS#before-getting-started)
+
+Here is an example usage:
+
+```typescript
+const appInsightsClient = new ApplicationInsights({
+	config: {
+		connectionString:
+			"InstrumentationKey=abcdefgh-ijkl-mnop-qrst-uvwxyz6ffd9c;IngestionEndpoint=https://westus2-2.in.applicationinsights.azure.com/;LiveEndpoint=https://westus2.livediagnostics.monitor.azure.com/",
+	},
+});
+
+// Initializes the App Insights client. Without this, logs will not be sent to Azure.
+appInsightsClient.loadAppInsights();
+
+const logger = new FluidAppInsightsLogger(appInsightsClient);
+
+// Example of sending an event to app insights using the FluidAppInsightsLogger directly
+logger.send({ category: "mockEvent", eventName: "mockEventName" });
+
+// More commonly, we would provide the logger to the instance of the Fluid Loader used by your application. This enables Fluid telemetry to be automatically sent to App Insights as your Fluid App is running.
+const tinyliciousClient = new TinyliciousClient({
+	logger,
+});
+
+const createContainerResult = await tinyliciousClient.createContainer(containerSchema);
+```
+
+## Viewing Logs in App Insights
+
+From the Azure web portal, navigate to your app insights instance. Now, go to the "Logs" for your instance, this should be an option within the left side panel. Finally, from this page, you can query for telemetry events, which will be stored in the customEvents table. As an example, you can issue this simple query to get recent telemetry events sent to the customEvents table:
+
+-   Get a count of each distinct log event name and category of log event
+
+    ```
+    customEvents
+    | summarize count() by name, tostring(customDimensions.category)
+    ```
+
+-   Get all performance related logs
+
+    ```
+    customEvents
+    | where customDimensions.name == "performance"
+    ```
+
+<!-- AUTO-GENERATED-CONTENT:START (README_API_DOCS_SECTION:includeHeading=TRUE) -->
+
+<!-- prettier-ignore-start -->
+
+<!-- This section is automatically generated. To update it, make the appropriate changes to docs/md-magic.config.js or the embedded content, then run 'npm run build:md-magic' in the docs folder. -->
+
+<!-- prettier-ignore-end -->
+
+<!-- AUTO-GENERATED-CONTENT:END -->
+
+<!-- AUTO-GENERATED-CONTENT:START (README_HELP_SECTION:includeHeading=TRUE) -->
+
+<!-- prettier-ignore-start -->
+<!-- NOTE: This section is automatically generated using @fluid-tools/markdown-magic. Do not update these generated contents directly. -->
+
+## Help
+
+Not finding what you're looking for in this README? Check out our [GitHub
+Wiki](https://github.com/microsoft/FluidFramework/wiki) or [fluidframework.com](https://fluidframework.com/docs/).
+
+Still not finding what you're looking for? Please [file an
+issue](https://github.com/microsoft/FluidFramework/wiki/Submitting-Bugs-and-Feature-Requests).
+
+Thank you!
+
+<!-- prettier-ignore-end -->
+
+<!-- AUTO-GENERATED-CONTENT:END -->
+
+<!-- AUTO-GENERATED-CONTENT:START (README_CONTRIBUTION_GUIDELINES_SECTION:includeHeading=TRUE) -->
+
+<!-- prettier-ignore-start -->
+<!-- NOTE: This section is automatically generated using @fluid-tools/markdown-magic. Do not update these generated contents directly. -->
+
+## Contribution Guidelines
+
+There are many ways to [contribute](https://github.com/microsoft/FluidFramework/blob/main/CONTRIBUTING.md) to Fluid.
+
+-   Participate in Q&A in our [GitHub Discussions](https://github.com/microsoft/FluidFramework/discussions).
+-   [Submit bugs](https://github.com/microsoft/FluidFramework/issues) and help us verify fixes as they are checked in.
+-   Review the [source code changes](https://github.com/microsoft/FluidFramework/pulls).
+-   [Contribute bug fixes](https://github.com/microsoft/FluidFramework/blob/main/CONTRIBUTING.md).
+
+Detailed instructions for working in the repo can be found in the [Wiki](https://github.com/microsoft/FluidFramework/wiki).
+
+This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
+For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
+
+This project may contain Microsoft trademarks or logos for Microsoft projects, products, or services.
+Use of these trademarks or logos must follow Microsoft’s [Trademark & Brand Guidelines](https://www.microsoft.com/trademarks).
+Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship.
+
+<!-- prettier-ignore-end -->
+
+<!-- AUTO-GENERATED-CONTENT:END -->
+
+<!-- AUTO-GENERATED-CONTENT:START (README_TRADEMARK_SECTION:includeHeading=TRUE) -->
+
+<!-- prettier-ignore-start -->
+<!-- NOTE: This section is automatically generated using @fluid-tools/markdown-magic. Do not update these generated contents directly. -->
+
+## Trademark
+
+This project may contain Microsoft trademarks or logos for Microsoft projects, products, or services.
+
+Use of these trademarks or logos must follow Microsoft's [Trademark & Brand Guidelines](https://www.microsoft.com/en-us/legal/intellectualproperty/trademarks/usage/general).
+
+Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship.
+
+<!-- prettier-ignore-end -->
+
+<!-- AUTO-GENERATED-CONTENT:END -->

package/api-extractor.json

@@ -0,0 +1,20 @@
+{
+	"$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
+	"extends": "@fluidframework/build-common/api-extractor-base.json",
+
+	"messages": {
+		// The following overrides are workarounds for API-Extractor incorrectly running analysis on our application
+		// insights dependency.
+		"tsdocMessageReporting": {
+			"tsdoc-escape-right-brace": {
+				"logLevel": "none"
+			},
+			"tsdoc-malformed-inline-tag": {
+				"logLevel": "none"
+			},
+			"tsdoc-undefined-tag": {
+				"logLevel": "none"
+			}
+		}
+	}
+}

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

@@ -0,0 +1,42 @@
+## API Report File for "@fluidframework/app-insights-logger"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```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
+export interface CategoryFilter {
+    categories: TelemetryEventCategory[];
+}
+
+// @public @sealed
+export class FluidAppInsightsLogger implements ITelemetryBaseLogger {
+    constructor(client: ApplicationInsights, config?: FluidAppInsightsLoggerConfig);
+    send(event: ITelemetryBaseEvent): void;
+}
+
+// @public
+export interface FluidAppInsightsLoggerConfig {
+    filtering: {
+        mode: "inclusive" | "exclusive";
+        filters?: TelemetryFilter[];
+    };
+}
+
+// @public
+export interface NamespaceFilter {
+    namespacePattern: string;
+    namespacePatternExceptions?: Set<string>;
+}
+
+export { TelemetryEventCategory }
+
+// @public
+export type TelemetryFilter = CategoryFilter | NamespaceFilter | (CategoryFilter & NamespaceFilter);
+
+```

package/dist/fluidAppInsightsLogger.d.ts

@@ -0,0 +1,164 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { type ApplicationInsights } from "@microsoft/applicationinsights-web";
+import { type ITelemetryBaseEvent, type ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
+import { type TelemetryEventCategory } from "@fluidframework/telemetry-utils";
+/**
+ * The configuration object for the {@link FluidAppInsightsLogger}
+ *
+ * @public
+ */
+export 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 category of a telemetry event
+ *
+ * @public
+ */
+export interface CategoryFilter {
+    /**
+     * The categories of telemetry events that this filter applies to
+     */
+    categories: TelemetryEventCategory[];
+}
+/**
+ * A filter used to match against the namespaces of a telemetry event
+ *
+ * @public
+ */
+export 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>;
+}
+/**
+ * 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.
+ *
+ * @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
+ * ```
+ * const logger = new FluidAppInsightsLogger(appInsightsClient, {
+ *			filtering: {
+ *				mode: "inclusive",
+ *				filters: [
+ *					{
+ *						namespacePattern: "A:B",
+ *						categories: ["generic", "error"],
+ *					},
+ *					{
+ *						namespacePattern: "A:B:C",
+ *						categories: ["error"],
+ *					},
+ *				],
+ *			},
+ *		});
+ * ```
+ */
+export type TelemetryFilter = CategoryFilter | NamespaceFilter | (CategoryFilter & NamespaceFilter);
+/**
+ * An implementation of {@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.
+ *
+ * @sealed
+ * @public
+ */
+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;
+}
+//# sourceMappingURL=fluidAppInsightsLogger.d.ts.map

package/dist/fluidAppInsightsLogger.d.ts.map

@@ -0,0 +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"}

package/dist/fluidAppInsightsLogger.js

@@ -0,0 +1,172 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FluidAppInsightsLogger = void 0;
+/**
+ * An implementation of {@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.
+ *
+ * @sealed
+ * @public
+ */
+class FluidAppInsightsLogger {
+    constructor(client, config) {
+        this.baseLoggingClient = client;
+        // Deep copy config to prevent issues if user mutates the object they passed in
+        this.config = config
+            ? structuredClone(config)
+            : {
+                filtering: {
+                    mode: "exclusive",
+                    filters: [],
+                },
+            };
+        if (this.config.filtering.filters) {
+            this.validateFilters(this.config.filtering.filters);
+            // Sort filters by longest namespace first.
+            this.config.filtering.filters.sort((a, b) => {
+                const namespaceALength = "namespacePattern" in a && a.namespacePattern !== undefined
+                    ? a.namespacePattern.length
+                    : 0;
+                const namespaceBLength = "namespacePattern" in b && b.namespacePattern !== undefined
+                    ? b.namespacePattern.length
+                    : 0;
+                return namespaceBLength - namespaceALength;
+            });
+        }
+    }
+    /**
+     * 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) {
+        if (this.shouldSendEvent(event)) {
+            this.baseLoggingClient.trackEvent({
+                name: event.eventName,
+                properties: event,
+            });
+        }
+    }
+    shouldSendEvent(event) {
+        // No events should be sent by default in "inclusive" mode, and all events should be
+        // sent by default in "exclusive" mode.
+        let shouldSendEvent = this.config.filtering.mode === "inclusive" ? false : true;
+        if (this.doesEventMatchFilter(event)) {
+            // If the event does match a filter, in "inclusive" filter mode that means it should
+            // be sent (included). In "exclusive" mode the opposite is true.
+            shouldSendEvent = this.config.filtering.mode === "inclusive" ? true : false;
+        }
+        return 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`.
+     */
+    doesEventMatchFilter(event) {
+        for (const filter of this.config.filtering.filters ?? []) {
+            if ("namespacePattern" in filter && filter.namespacePattern !== undefined) {
+                if (event.eventName.startsWith(filter.namespacePattern)) {
+                    // Found matching namespace pattern, since filters are ordered in most specific first,
+                    // this is the most specific, relevant matching filter for the event.
+                    // By default, if no categories are defined then any category is a valid match.
+                    let doesFilterCategoriesMatch = true;
+                    if ("categories" in filter &&
+                        filter.categories !== undefined &&
+                        filter.categories.length > 0) {
+                        doesFilterCategoriesMatch = false;
+                        const matchingCategory = filter.categories.find((category) => category === event.category);
+                        doesFilterCategoriesMatch = matchingCategory ? true : false;
+                    }
+                    if (doesFilterCategoriesMatch) {
+                        // The most specific, relevant filter matches so no need to attempt to evaluate against other filters
+                        // as long as the events namespace does not match any defined namespace exception.
+                        if (filter.namespacePatternExceptions !== undefined) {
+                            for (const patternException of filter.namespacePatternExceptions) {
+                                if (event.eventName.startsWith(patternException)) {
+                                    return false;
+                                }
+                            }
+                        }
+                        return true;
+                    }
+                    else {
+                        return false;
+                    }
+                }
+            }
+            // Filter only has categories defined
+            else if ("categories" in filter &&
+                filter.categories !== undefined &&
+                filter.categories.length > 0) {
+                const doesFilterCategoriesMatch = filter.categories.find((category) => category === event.category);
+                // This filter specified no namespaces but it has a category match.
+                // Since filters are ordered by most specific first, we know that no previous
+                // filters with namespaces matched so we can return true.
+                if (doesFilterCategoriesMatch) {
+                    return true;
+                }
+                else {
+                    continue;
+                }
+            }
+            else {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * 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.
+     */
+    validateFilters(filters) {
+        const uniqueFilterNamespaces = new Set();
+        for (const filter of filters) {
+            if ("namespacePattern" in filter && filter.namespacePattern !== undefined) {
+                if (uniqueFilterNamespaces.has(filter.namespacePattern)) {
+                    throw new Error("Cannot have duplicate namespace pattern filters");
+                }
+                else {
+                    uniqueFilterNamespaces.add(filter.namespacePattern);
+                }
+                for (const patternException of filter.namespacePatternExceptions ?? []) {
+                    if (!patternException.startsWith(filter.namespacePattern)) {
+                        throw new Error("Cannot have a namespace pattern exception that is not a child of the parent namespace");
+                    }
+                }
+            }
+            else if ("categories" in filter && filter.categories !== undefined) {
+                // These are filters that only contain "categories". For the purpose of this validation logic, we are treating filters
+                // that does not contain a defined namespace as the the same as a blank "" namespace pattern (which will match any event).
+                if (uniqueFilterNamespaces.has("")) {
+                    throw new Error("Cannot have multiple filters that only define categories");
+                }
+                uniqueFilterNamespaces.add("");
+            }
+            else {
+                throw new Error("Invalid filter does not have either a namespace or a category.");
+            }
+        }
+    }
+}
+exports.FluidAppInsightsLogger = FluidAppInsightsLogger;
+//# sourceMappingURL=fluidAppInsightsLogger.js.map