@equinor/fusion-framework-module-analytics 0.1.1

package/dist/types/AnalyticsConfigurator.d.ts

@@ -0,0 +1,39 @@
+import { BaseConfigBuilder, type ConfigBuilderCallback } from '@equinor/fusion-framework-module';
+import type { IAnalyticsConfigurator, AnalyticsConfig } from './AnalyticsConfigurator.interface.js';
+import type { IAnalyticsCollector } from './collectors/AnalyticsCollector.interface.js';
+import type { IAnalyticsAdapter } from './adapters/AnalyticsAdapter.interface.js';
+import type { AnalyticsEvent } from './types.js';
+/**
+ * Configures analytics settings for the module.
+ *
+ * The `AnalyticsConfigurator` class extends `BaseConfigBuilder` to provide a fluent API for
+ * setting up analytics adapters and collectors.
+ *
+ * @remarks
+ * - Adapters are managed internally and can be set using `setAdapter`.
+ * - Collectors are managed internally and can be set using `setCollector`.
+ * - All setter methods return `this` for method chaining.
+ *
+ * @see BaseConfigBuilder
+ * @see IAnalyticsConfigurator
+ */
+export declare class AnalyticsConfigurator extends BaseConfigBuilder<AnalyticsConfig> implements IAnalyticsConfigurator {
+    #private;
+    constructor();
+    /**
+     * Registers a analytics collector with the configurator.
+     *
+     * @param identifier - The name of the collector
+     * @param callback - A callback function that returns an analytics collector instance
+     * @returns The current instance for method chaining
+     */
+    setCollector<T extends AnalyticsEvent>(identifier: string, callback: ConfigBuilderCallback<IAnalyticsCollector<T>>): this;
+    /**
+     * Registers a analytics adapter with the configurator.
+     *
+     * @param identifier - The name of the adapter
+     * @param callback - A callback function that returns an analytics adapter instance
+     * @returns The current instance for method chaining
+     */
+    setAdapter<T extends AnalyticsEvent>(identifier: string, callback: ConfigBuilderCallback<IAnalyticsAdapter<T>>): this;
+}

package/dist/types/AnalyticsConfigurator.interface.d.ts

@@ -0,0 +1,39 @@
+import type { ConfigBuilderCallback } from '@equinor/fusion-framework-module';
+import type { IAnalyticsCollector } from './collectors/AnalyticsCollector.interface.js';
+import type { IAnalyticsAdapter } from './adapters/AnalyticsAdapter.interface.js';
+import type { AnalyticsEvent } from './types.js';
+/**
+ * Configuration options for setting up analytics within the framework.
+ *
+ * @property collectors - Record of analytics collectors keyed by identifier to be used for reporting analytics data.
+ * @property adapters - Record of analytics adapters keyed by identifier to be used to handle events.
+ */
+export type AnalyticsConfig = {
+    collectors: Record<string, IAnalyticsCollector>;
+    adapters: Record<string, IAnalyticsAdapter>;
+};
+/**
+ * Interface for configuring analytics within the module.
+ *
+ * Provides methods to set analytics adapters and collectors.
+ *
+ * @interface IAnalyticsConfigurator
+ */
+export interface IAnalyticsConfigurator {
+    /**
+     * Sets a analytics collector with the given identifier and configuration callback.
+     *
+     * @param identifier - The unique identifier for the collector.
+     * @param callBack - Configuration callback that returns the collector instance.
+     * @returns The configurator instance for method chaining.
+     */
+    setCollector<T extends AnalyticsEvent>(identifier: string, callBack: ConfigBuilderCallback<IAnalyticsCollector<T>>): this;
+    /**
+     * Sets a analytics adapter with the given identifier and configuration callback.
+     *
+     * @param identifier - The unique identifier for the adapter.
+     * @param callBack - Configuration callback that returns the adapter instance.
+     * @returns The configurator instance for method chaining.
+     */
+    setAdapter<T extends AnalyticsEvent>(identifier: string, callback: ConfigBuilderCallback<IAnalyticsAdapter<T>>): this;
+}

package/dist/types/AnalyticsProvider.d.ts

@@ -0,0 +1,45 @@
+import { BaseModuleProvider } from '@equinor/fusion-framework-module/provider';
+import type { AnalyticsConfig } from './AnalyticsConfigurator.interface.js';
+import type { IAnalyticsProvider } from './AnalyticsProvider.interface.js';
+import type { AnalyticsEvent } from './types.js';
+import { type ObservableInput, Subscription } from 'rxjs';
+/**
+ * Provides analytics tracking, adapters integration and collectors for application instrumentation.
+ *
+ * The `AnalyticsProvider` class is responsible for collecting, processing and relaying analytics
+ * data to the adapters. The events are collected with collectors.
+ *
+ * @typeParam AnalyticsConfig - The configuration type for analytics.
+ * @implements IAnalyticsProvider
+ * @extends BaseModuleProvider<AnalyticsConfig>
+ */
+export declare class AnalyticsProvider extends BaseModuleProvider<AnalyticsConfig> implements IAnalyticsProvider {
+    #private;
+    constructor(config: AnalyticsConfig);
+    /**
+     * Initializes the analytics provider with adapters and collectors.
+     *
+     * This method sets up the provider for operation by:
+     * 1. Storing the provided adapters
+     * 2. Initializing all adapters
+     * 3. Storing the provided collectors
+     * 4. Initializing all collectors
+     * 5. Setting up subscription for analytics processing
+     *
+     * @returns A promise that resolves when initialization is complete
+     */
+    initialize(): Promise<void>;
+    /**
+     * Tracks an analytics event
+     *
+     * @param event - The analytics event to track
+     */
+    trackAnalytic(event: AnalyticsEvent): void;
+    /**
+     * Uses a analytics stream and returns both Disposable and Subscription for cleanup.
+     *
+     * @param analytic$ - Observable input stream of analytic events.
+     * @returns Object containing both Disposable and Subscription for proper cleanup.
+     */
+    trackAnalytic$(analytic$: ObservableInput<AnalyticsEvent>): Disposable & Subscription;
+}

package/dist/types/AnalyticsProvider.interface.d.ts

@@ -0,0 +1,20 @@
+import type { ObservableInput, Subscription } from 'rxjs';
+import type { AnalyticsEvent } from './types.js';
+/**
+ * Interface for analytics providers used to track analytics events.
+ */
+export interface IAnalyticsProvider {
+    /**
+     * Tracks a analytics event.
+     *
+     * @param event - The analytic event to track.
+     */
+    trackAnalytic(event: AnalyticsEvent): void;
+    /**
+     * Uses a analytics stream and returns both Disposable and Subscription for cleanup.
+     *
+     * @param analytic$ - Observable input stream of analytic events.
+     * @returns Object containing both Disposable and Subscription for proper cleanup.
+     */
+    trackAnalytic$(analytic$: ObservableInput<AnalyticsEvent>): Disposable & Subscription;
+}

package/dist/types/adapters/AnalyticsAdapter.interface.d.ts

@@ -0,0 +1,21 @@
+import type { AnalyticsEvent } from '../types.js';
+/**
+ * Interface representing an analytics adapter responsible for handling analytics events.
+ *
+ * @template T - The type of analytics event handled by the adapter. Defaults to `AnalyticsEvent`.
+ */
+export interface IAnalyticsAdapter<T extends AnalyticsEvent = AnalyticsEvent> extends Disposable {
+    /**
+     * Initializes the analytics adapter for setup and configuration.
+     *
+     * @returns Promise that resolves when initialization is complete, or void for synchronous initialization.
+     */
+    initialize?(): Promise<void> | void;
+    /**
+     * Exports analytics event to the configured backend.
+     *
+     * @param events - Array of analytics events to export.
+     * @returns Promise that resolves when export is complete.
+     */
+    registerAnalytic(event: T): Promise<void> | void;
+}

package/dist/types/adapters/ConsoleAnalyticsAdapter.d.ts

@@ -0,0 +1,9 @@
+import type { IAnalyticsAdapter } from './AnalyticsAdapter.interface.js';
+import type { AnalyticsEvent } from '../types.js';
+/**
+ * An analytics adapter printing the events to the console.
+ */
+export declare class ConsoleAnalyticsAdapter<T extends AnalyticsEvent = AnalyticsEvent> implements IAnalyticsAdapter {
+    registerAnalytic(event: T): Promise<void> | void;
+    [Symbol.dispose](): void;
+}

package/dist/types/adapters/FusionAnalyticsAdapter.d.ts

@@ -0,0 +1,19 @@
+import type { IAnalyticsAdapter } from './AnalyticsAdapter.interface.js';
+import type { AnalyticsEvent } from '../types.js';
+import { type ReadableLogRecord } from '@opentelemetry/sdk-logs';
+import type { OTLPExporterBase } from '@opentelemetry/otlp-exporter-base';
+/**
+ * An analytics adapter for sending events to the log exporter for handling.
+ *
+ * The exporter is a Open Telemetry exporter.
+ * @see OTLPExporterBase
+ */
+export declare class FusionAnalyticsAdapter<T extends AnalyticsEvent = AnalyticsEvent> implements IAnalyticsAdapter {
+    #private;
+    constructor(args: {
+        portalId: string;
+        logExporter: OTLPExporterBase<ReadableLogRecord[]>;
+    });
+    registerAnalytic(event: T): Promise<void> | void;
+    [Symbol.dispose](): void;
+}

package/dist/types/adapters/index.d.ts

@@ -0,0 +1,3 @@
+export { IAnalyticsAdapter } from './AnalyticsAdapter.interface.js';
+export { ConsoleAnalyticsAdapter } from './ConsoleAnalyticsAdapter.js';
+export { FusionAnalyticsAdapter } from './FusionAnalyticsAdapter.js';

package/dist/types/collectors/AnalyticsCollector.interface.d.ts

@@ -0,0 +1,16 @@
+import type { Subscribable } from 'rxjs';
+import type { AnalyticsEvent } from '../types.js';
+/**
+ * Interface representing an analytics collector responsible for sending analytics events.
+ *
+ * @template T - The type of analytics event handled by the adapter. Defaults to `AnalyticsEvent`.
+ */
+export interface IAnalyticsCollector<T extends AnalyticsEvent = AnalyticsEvent> extends Subscribable<T> {
+    /**
+     * Initializes the analytics collector for setup and configuration.
+     * This method is optional - if not implemented, the collector should be directly subscribable.
+     *
+     * @returns Promise that resolves when initialization is complete, or void for synchronous initialization.
+     */
+    initialize?(): Promise<void> | void;
+}

package/dist/types/collectors/AppLoadedCollector.d.ts

@@ -0,0 +1,23 @@
+import { BaseCollector } from './BaseCollector.js';
+import { type AppItemType } from './utils/extractAppMetadata.js';
+import { type ContextItemType } from './utils/extractContextMetadata.js';
+import type { IAnalyticsCollector } from './AnalyticsCollector.interface.js';
+import type { AppModuleProvider } from '@equinor/fusion-framework-module-app';
+import type { IEventModuleProvider } from '@equinor/fusion-framework-module-event';
+import { type ObservableInput } from 'rxjs';
+/**
+ * Collector to listen for app loaded and add values and attributes for
+ * further processing by adapters.
+ */
+export declare class AppLoadedCollector extends BaseCollector<AppItemType, {
+    context?: ContextItemType;
+}> implements IAnalyticsCollector {
+    #private;
+    constructor(eventProvider: IEventModuleProvider, appProvider: AppModuleProvider);
+    _initialize(): ObservableInput<{
+        value: AppItemType;
+        attributes: {
+            context?: ContextItemType;
+        };
+    }>;
+}

package/dist/types/collectors/AppSelectedCollector.d.ts

@@ -0,0 +1,21 @@
+import { type ObservableInput } from 'rxjs';
+import type { IAnalyticsCollector } from './AnalyticsCollector.interface.js';
+import { BaseCollector } from './BaseCollector.js';
+import { type AppKeyType } from './utils/extractAppMetadata.js';
+import type { AppModuleProvider } from '@equinor/fusion-framework-module-app';
+/**
+ * Collector to listen for app selection and add values and attributes for
+ * further processing by adapters.
+ */
+export declare class AppSelectedCollector extends BaseCollector<AppKeyType, {
+    previous?: AppKeyType;
+}> implements IAnalyticsCollector {
+    #private;
+    constructor(appProvider: AppModuleProvider);
+    _initialize(): ObservableInput<{
+        value: AppKeyType;
+        attributes: {
+            previous?: AppKeyType;
+        };
+    }>;
+}

package/dist/types/collectors/BaseCollector.d.ts

@@ -0,0 +1,27 @@
+import type { AnyValue, AnyValueMap, AnalyticsEvent } from '../types.js';
+import type { IAnalyticsCollector } from './AnalyticsCollector.interface.js';
+import { type ObservableInput, type Observer, type Unsubscribable } from 'rxjs';
+import { z } from 'zod';
+/**
+ * Function to create zod schema to be used when collecting
+ */
+export declare const createSchema: <TValue = AnyValue, TAttr = AnyValueMap>(value: z.ZodSchema<TValue>, attributes: z.ZodSchema<TAttr>) => z.ZodObject<{
+    name: z.ZodString;
+    value: z.ZodType<TValue, unknown, z.core.$ZodTypeInternals<TValue, unknown>>;
+    attributes: z.ZodOptional<z.ZodType<TAttr, unknown, z.core.$ZodTypeInternals<TAttr, unknown>>>;
+}, z.core.$strip>;
+export type CollectorSchema<TValue = AnyValue, TAttr = AnyValueMap> = ReturnType<typeof createSchema<TValue, TAttr>>;
+/**
+ * A base collector to help with parsing the events with provided schema before
+ * emitting.
+ */
+export declare abstract class BaseCollector<TValue extends AnyValue, TAttr extends AnyValueMap = AnyValueMap> implements IAnalyticsCollector<AnalyticsEvent<TValue, TAttr>> {
+    #private;
+    constructor(name: string, schema: CollectorSchema<TValue, TAttr>);
+    abstract _initialize(): ObservableInput<{
+        value: TValue;
+        attributes: TAttr;
+    }>;
+    initialize(): Promise<void> | void;
+    subscribe(observer: Partial<Observer<z.infer<CollectorSchema<TValue, TAttr>>>>): Unsubscribable;
+}

package/dist/types/collectors/ContextSelectedCollector.d.ts

@@ -0,0 +1,21 @@
+import { type ObservableInput } from 'rxjs';
+import type { IAnalyticsCollector } from './AnalyticsCollector.interface.js';
+import type { IContextProvider } from '@equinor/fusion-framework-module-context';
+import { BaseCollector } from './BaseCollector.js';
+import { type ContextItemType } from './utils/extractContextMetadata.js';
+/**
+ * Collector to listen for context changes and add values and attributes for
+ * further processing by adapters.
+ */
+export declare class ContextSelectedCollector extends BaseCollector<ContextItemType, {
+    previous?: ContextItemType;
+}> implements IAnalyticsCollector {
+    #private;
+    constructor(contextProvider: IContextProvider);
+    _initialize(): ObservableInput<{
+        value: ContextItemType;
+        attributes: {
+            previous?: ContextItemType;
+        };
+    }>;
+}

package/dist/types/collectors/index.d.ts

@@ -0,0 +1,4 @@
+export { IAnalyticsCollector } from './AnalyticsCollector.interface.js';
+export { ContextSelectedCollector } from './ContextSelectedCollector.js';
+export { AppSelectedCollector } from './AppSelectedCollector.js';
+export { AppLoadedCollector } from './AppLoadedCollector.js';

package/dist/types/collectors/utils/extractAppMetadata.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import type { AppManifest, CurrentApp } from '@equinor/fusion-framework-module-app';
+export declare const appKeySchema: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+    appKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>>;
+export declare const appSchema: z.ZodOptional<z.ZodObject<{
+    appKey: z.ZodString;
+    displayName: z.ZodString;
+    type: z.ZodString;
+    categoryName: z.ZodOptional<z.ZodString>;
+    buildVersion: z.ZodOptional<z.ZodString>;
+    buildTag: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>>;
+export type AppKeyType = z.infer<typeof appKeySchema>;
+export type AppItemType = z.infer<typeof appSchema>;
+export declare const extractAppKeyMetadata: (app: CurrentApp) => z.input<typeof appKeySchema>;
+export declare const extractAppMetadata: (app: AppManifest) => z.input<typeof appSchema>;

package/dist/types/collectors/utils/extractContextMetadata.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import type { ContextItem } from '@equinor/fusion-framework-module-context';
+export declare const contextSchema: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    externalId: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>>;
+export type ContextItemType = z.infer<typeof contextSchema>;
+export declare const extractContextMetadata: (context: ContextItem) => z.input<typeof contextSchema>;

package/dist/types/enable-analytics.d.ts

@@ -0,0 +1,11 @@
+import type { IModulesConfigurator } from '@equinor/fusion-framework-module';
+import type { IAnalyticsConfigurator } from './AnalyticsConfigurator.interface.js';
+type AnalyticsBuilderCallback = (builder: IAnalyticsConfigurator) => void | Promise<void>;
+/**
+ * Enables analytics for agiven module configurator.
+ *
+ * @param configurator - The module configurator instance to which analytics should be attached.
+ * @param callback - An optional callback to further configure the analytics builder. Can be synchronous or asynchronous.
+ */
+export declare const enableAnalytics: (configurator: IModulesConfigurator<any, any>, callback?: AnalyticsBuilderCallback) => void;
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+export { module as analyticsModule, AnalyticsModule } from './module.js';
+export { AnalyticsEvent } from './types.js';
+export { AnalyticsProvider } from './AnalyticsProvider.js';
+export { IAnalyticsProvider } from './AnalyticsProvider.interface.js';
+export { AnalyticsConfig, IAnalyticsConfigurator } from './AnalyticsConfigurator.interface.js';
+export { AnalyticsConfigurator } from './AnalyticsConfigurator.js';
+export { enableAnalytics } from './enable-analytics.js';

package/dist/types/logExporters/fusionOTLPLogExporter/FusionOTLPLogExporter.d.ts

@@ -0,0 +1,11 @@
+import type { LogRecordExporter, ReadableLogRecord } from '@opentelemetry/sdk-logs';
+import { OTLPExporterBase } from '@opentelemetry/otlp-exporter-base';
+import type { IHttpClient } from '@equinor/fusion-framework-module-http';
+/**
+ * A log exporter extending OTLPExporterBase but substitute the normal transport
+ * with a HttpClientExporterTransport. This will use the provided httpClient to
+ * emit the event.
+ */
+export declare class FusionOTLPLogExporter extends OTLPExporterBase<ReadableLogRecord[]> implements LogRecordExporter {
+    constructor(httpClient: IHttpClient);
+}

package/dist/types/logExporters/fusionOTLPLogExporter/HttpClientExporterTransport.d.ts

@@ -0,0 +1,12 @@
+import type { IExporterTransport, ExportResponse } from '@opentelemetry/otlp-exporter-base';
+import type { IHttpClient } from '@equinor/fusion-framework-module-http';
+/**
+ * A Exporter Transport to POST events to provided path using the provided httpClient
+ */
+export declare class HttpClientExporterTransport implements IExporterTransport {
+    private httpClient;
+    private path;
+    constructor(httpClient: IHttpClient, path?: string);
+    send(data: Uint8Array, timeoutMillis: number): Promise<ExportResponse>;
+    shutdown(): void;
+}

package/dist/types/logExporters/index.d.ts

@@ -0,0 +1,2 @@
+export { FusionOTLPLogExporter } from './fusionOTLPLogExporter/FusionOTLPLogExporter.js';
+export { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';

package/dist/types/module.d.ts

@@ -0,0 +1,44 @@
+import type { Module } from '@equinor/fusion-framework-module';
+import type { IAnalyticsConfigurator } from './AnalyticsConfigurator.interface.js';
+import type { IAnalyticsProvider } from './AnalyticsProvider.interface.js';
+import { AnalyticsConfigurator } from './AnalyticsConfigurator.js';
+/**
+ * Representes the Analytics module within the framework.
+ *
+ * @remarks
+ * This type defines a module names `analytics` that integrates with the framwork's module system.
+ * It specifies the provider and configurator interfaces for analytics functionality, and declares
+ * its dependencies on itself (`AnalyticsModule`).
+ *
+ * @typeParam IAnalyticsProvider - The interface for the analytics provider implementation.
+ * @typeParam IAnalyticsConfigurator - The interface for configuring analytics behavior.
+ * @typeParam AnalyticsModule - Self-reference to allow for recursive or hierarchical module composition.
+ */
+export type AnalyticsModule = Module<'analytics', IAnalyticsProvider, IAnalyticsConfigurator, [
+    AnalyticsModule
+]>;
+/**
+ * Analytics module definition for the Fusion Framework.
+ *
+ * @remarks
+ * This module provides analytics capabilities by configuring and initializing a analytics provider.
+ *
+ * @type {AnalyticsModule}
+ *
+ * @property {string} name - The name of the module ('analytics').
+ * @property {() => AnalyticsConfigurator} configure - Factory function to create a new AnalyticsConfigurator instance.
+ * @property {(args) => Promise<IAnalyticsProvider>} initialize - Asynchronous initializer that creates and returns a AnalyticsProvider.
+ *   - @param args - Initialization arguments, including configuration and module dependencies.
+ *   - @returns A promise that resolves to an instance of IAnalyticsProvider.
+ */
+export declare const module: {
+    name: "analytics";
+    configure: () => AnalyticsConfigurator;
+    initialize: (args: import("@equinor/fusion-framework-module").ModuleInitializerArgs<IAnalyticsConfigurator, [AnalyticsModule]>) => Promise<IAnalyticsProvider>;
+};
+export default module;
+declare module '@equinor/fusion-framework-module' {
+    interface Modules {
+        analytics: AnalyticsModule;
+    }
+}

package/dist/types/types.d.ts

@@ -0,0 +1,22 @@
+export type AnyValueScalar = string | number | boolean;
+export type AnyValueArray = Array<AnyValue>;
+/**
+ * AnyValueMap is a map from string to AnyValue (attribute value or a nested map)
+ */
+export interface AnyValueMap {
+    [attributeKey: string]: AnyValue;
+}
+/**
+ * AnyValue can be one of the following:
+ * - a scalar value
+ * - a byte array
+ * - array of any value
+ * - map from string to any value
+ * - empty value
+ */
+export type AnyValue = AnyValueScalar | Uint8Array | AnyValueArray | AnyValueMap | null | undefined;
+export type AnalyticsEvent<TValue extends AnyValue = AnyValue, TAttr extends AnyValueMap = AnyValueMap> = {
+    name: string;
+    value: TValue;
+    attributes?: TAttr;
+};

package/dist/types/version.d.ts

@@ -0,0 +1 @@
+export declare const version = "0.1.1";

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@equinor/fusion-framework-module-analytics",
+  "version": "0.1.1",
+  "description": "Fusion module for collecting and exporting application analytics using OpenTelemetry standards",
+  "main": "dist/esm/index.js",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "types": "./dist/types/index.d.ts"
+    },
+    "./adapters": {
+      "import": "./dist/esm/adapters/index.js",
+      "types": "./dist/types/adapters/index.d.ts"
+    },
+    "./collectors": {
+      "import": "./dist/esm/collectors/index.js",
+      "types": "./dist/types/collectors/index.d.ts"
+    },
+    "./logExporters": {
+      "import": "./dist/esm/logExporters/index.js",
+      "types": "./dist/types/logExporters/index.d.ts"
+    }
+  },
+  "types": "dist/types/index.d.ts",
+  "keywords": [
+    "analytics",
+    "fusion",
+    "utility"
+  ],
+  "author": "",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/equinor/fusion-framework.git",
+    "directory": "packages/modules/analytics"
+  },
+  "dependencies": {
+    "@opentelemetry/api-logs": "^0.207.0",
+    "@opentelemetry/exporter-logs-otlp-http": "^0.207.0",
+    "@opentelemetry/otlp-exporter-base": "^0.207.0",
+    "@opentelemetry/otlp-transformer": "^0.208.0",
+    "@opentelemetry/resources": "^2.2.0",
+    "@opentelemetry/sdk-logs": "^0.207.0",
+    "deepmerge": "^4.3.1",
+    "rxjs": "^7.8.1",
+    "uuid": "^13.0.0",
+    "zod": "^4.1.11",
+    "@equinor/fusion-framework-module": "^5.0.5",
+    "@equinor/fusion-framework-module-event": "^4.4.0",
+    "@equinor/fusion-framework-module-http": "^7.0.5",
+    "@equinor/fusion-framework-module-app": "^7.2.1",
+    "@equinor/fusion-framework-module-context": "^7.0.2"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.2",
+    "vitest": "^3.2.4",
+    "@equinor/fusion-observable": "^8.5.7"
+  },
+  "peerDependencies": {
+    "@equinor/fusion-framework-module": "^5.0.5",
+    "@equinor/fusion-framework-module-event": "^4.4.0",
+    "@equinor/fusion-observable": "^8.5.7"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "test": "vitest"
+  }
+}

package/src/AnalyticsConfigurator.interface.ts

@@ -0,0 +1,48 @@
+import type { ConfigBuilderCallback } from '@equinor/fusion-framework-module';
+import type { IAnalyticsCollector } from './collectors/AnalyticsCollector.interface.js';
+import type { IAnalyticsAdapter } from './adapters/AnalyticsAdapter.interface.js';
+import type { AnalyticsEvent } from './types.js';
+
+/**
+ * Configuration options for setting up analytics within the framework.
+ *
+ * @property collectors - Record of analytics collectors keyed by identifier to be used for reporting analytics data.
+ * @property adapters - Record of analytics adapters keyed by identifier to be used to handle events.
+ */
+export type AnalyticsConfig = {
+  collectors: Record<string, IAnalyticsCollector>;
+  adapters: Record<string, IAnalyticsAdapter>;
+};
+
+/**
+ * Interface for configuring analytics within the module.
+ *
+ * Provides methods to set analytics adapters and collectors.
+ *
+ * @interface IAnalyticsConfigurator
+ */
+export interface IAnalyticsConfigurator {
+  /**
+   * Sets a analytics collector with the given identifier and configuration callback.
+   *
+   * @param identifier - The unique identifier for the collector.
+   * @param callBack - Configuration callback that returns the collector instance.
+   * @returns The configurator instance for method chaining.
+   */
+  setCollector<T extends AnalyticsEvent>(
+    identifier: string,
+    callBack: ConfigBuilderCallback<IAnalyticsCollector<T>>,
+  ): this;
+
+  /**
+   * Sets a analytics adapter with the given identifier and configuration callback.
+   *
+   * @param identifier - The unique identifier for the adapter.
+   * @param callBack - Configuration callback that returns the adapter instance.
+   * @returns The configurator instance for method chaining.
+   */
+  setAdapter<T extends AnalyticsEvent>(
+    identifier: string,
+    callback: ConfigBuilderCallback<IAnalyticsAdapter<T>>,
+  ): this;
+}