@equinor/fusion-framework-module-analytics 1.0.2 → 2.0.0

package/src/adapters/ConsoleAnalyticsAdapter.ts

@@ -2,11 +2,25 @@ import type { IAnalyticsAdapter } from './AnalyticsAdapter.interface.js';
 import type { AnalyticsEvent } from '../types.js';
 
 /**
- * An analytics adapter printing the events to the console.
+ * Analytics adapter that logs every event to the browser console.
+ *
+ * @remarks
+ * Useful during development and debugging. Each event is logged with the
+ * prefix `Analytics::Adapter::Console`.
+ *
+ * @template T - Analytics event type, defaults to {@link AnalyticsEvent}.
+ *
+ * @example
+ * ```ts
+ * import { ConsoleAnalyticsAdapter } from '@equinor/fusion-framework-module-analytics/adapters';
+ *
+ * builder.setAdapter('console', async () => new ConsoleAnalyticsAdapter());
+ * ```
  */
 export class ConsoleAnalyticsAdapter<T extends AnalyticsEvent = AnalyticsEvent>
   implements IAnalyticsAdapter
 {
+  /** Logs the event to the console. */
   registerAnalytic(event: T): Promise<void> | void {
     console.log('Analytics::Adapter::Console', event);
   }

package/src/adapters/FusionAnalyticsAdapter.ts

@@ -18,10 +18,30 @@ import { version } from '../version.js';
 import { v7 as uuid } from 'uuid';
 
 /**
- * An analytics adapter for sending events to the log exporter for handling.
+ * Analytics adapter that forwards events to an OpenTelemetry log exporter.
  *
- * The exporter is a Open Telemetry exporter.
- * @see OTLPExporterBase
+ * @remarks
+ * Uses `@opentelemetry/sdk-logs` to batch and export log records through the
+ * provided {@link OTLPExporterBase} transport. Each analytics event is mapped
+ * to an OTLP `LogRecord` with severity `INFO`.
+ *
+ * Resource attributes automatically include the module version, a unique
+ * session ID (UUIDv7), and the portal ID supplied at construction time.
+ *
+ * @template T - Analytics event type, defaults to {@link AnalyticsEvent}.
+ *
+ * @example
+ * ```ts
+ * import { FusionAnalyticsAdapter } from '@equinor/fusion-framework-module-analytics/adapters';
+ * import { OTLPLogExporter } from '@equinor/fusion-framework-module-analytics/logExporters';
+ *
+ * builder.setAdapter('fusion-log', async () => {
+ *   const logExporter = new OTLPLogExporter({ url: '/v1/logs' });
+ *   return new FusionAnalyticsAdapter({ portalId: 'my-portal', logExporter });
+ * });
+ * ```
+ *
+ * @see {@link OTLPExporterBase}
  */
 export class FusionAnalyticsAdapter<T extends AnalyticsEvent = AnalyticsEvent>
   implements IAnalyticsAdapter
@@ -30,6 +50,13 @@ export class FusionAnalyticsAdapter<T extends AnalyticsEvent = AnalyticsEvent>
   #loggerProvider: LoggerProvider;
   #logger: Logger;
 
+  /**
+   * Creates a new `FusionAnalyticsAdapter`.
+   *
+   * @param args - Construction options.
+   * @param args.portalId - Portal identifier attached to every exported log record.
+   * @param args.logExporter - An OTLP-compatible log exporter for transport.
+   */
   constructor(args: { portalId: string; logExporter: OTLPExporterBase<ReadableLogRecord[]> }) {
     this.#logExporter = args.logExporter;
 
@@ -44,6 +71,7 @@ export class FusionAnalyticsAdapter<T extends AnalyticsEvent = AnalyticsEvent>
     this.#logger = this.#loggerProvider.getLogger('fusion');
   }
 
+  /** Maps an analytics event to an OTLP `LogRecord` and emits it via the logger. */
   registerAnalytic(event: T): Promise<void> | void {
     const logRecord: Partial<LogRecord> = {
       eventName: event.name,
@@ -54,6 +82,7 @@ export class FusionAnalyticsAdapter<T extends AnalyticsEvent = AnalyticsEvent>
     this.#logger.emit(logRecord);
   }
 
+  /** Shuts down the log exporter and logger provider, flushing remaining records. */
   [Symbol.dispose]() {
     this.#logExporter.shutdown();
     this.#loggerProvider.shutdown();

package/src/adapters/index.ts

@@ -1,3 +1,11 @@
+/**
+ * Re-exports for built-in analytics adapters.
+ *
+ * @remarks
+ * Import from `'@equinor/fusion-framework-module-analytics/adapters'`.
+ *
+ * @packageDocumentation
+ */
 export { IAnalyticsAdapter } from './AnalyticsAdapter.interface.js';
 export { ConsoleAnalyticsAdapter } from './ConsoleAnalyticsAdapter.js';
 export { FusionAnalyticsAdapter } from './FusionAnalyticsAdapter.js';

package/src/collectors/AnalyticsCollector.interface.ts

@@ -2,9 +2,18 @@ import type { Subscribable } from 'rxjs';
 import type { AnalyticsEvent } from '../types.js';
 
 /**
- * Interface representing an analytics collector responsible for sending analytics events.
+ * Contract for an analytics collector that observes application state and emits
+ * structured analytics events.
  *
- * @template T - The type of analytics event handled by the adapter. Defaults to `AnalyticsEvent`.
+ * @remarks
+ * Implement this interface (or extend {@link BaseCollector}) to create a custom
+ * collector. Register it via {@link IAnalyticsConfigurator.setCollector}.
+ *
+ * The collector must be `Subscribable` so the provider can listen for emitted
+ * events. Optionally implement `initialize` for async setup (e.g. resolving
+ * module dependencies).
+ *
+ * @template T - Analytics event type emitted by this collector, defaults to {@link AnalyticsEvent}.
  */
 export interface IAnalyticsCollector<T extends AnalyticsEvent = AnalyticsEvent>
   extends Subscribable<T> {

package/src/collectors/AppLoadedCollector.ts

@@ -20,14 +20,26 @@ import type { ContextModule } from '@equinor/fusion-framework-module-context';
 
 const EVENT_NAME = 'onAppModulesLoaded';
 
-/**
- * The schema of the data to be sent.
- */
+/** Zod schema for the `app-loaded` event (value + attributes). */
 const eventSchema = createSchema(appSchema, z.object({ context: contextSchema }));
 
 /**
- * Collector to listen for app loaded and add values and attributes for
- * further processing by adapters.
+ * Collector that emits an analytics event whenever an application’s modules
+ * finish loading.
+ *
+ * @remarks
+ * Listens to the framework `onAppModulesLoaded` event, extracts application
+ * manifest metadata, and includes the current context (if available) in the
+ * event attributes.
+ *
+ * Register via:
+ * ```ts
+ * builder.setCollector('app-loaded', async (args) => {
+ *   const event = await args.requireInstance('event');
+ *   const app = await args.requireInstance('app');
+ *   return new AppLoadedCollector(event, app);
+ * });
+ * ```
  */
 export class AppLoadedCollector
   extends BaseCollector<AppItemType, { context?: ContextItemType }>
@@ -36,6 +48,10 @@ export class AppLoadedCollector
   #eventProvider: IEventModuleProvider;
   #appProvider: AppModuleProvider;
 
+  /**
+   * @param eventProvider - Fusion event module provider to listen for app-loaded events.
+   * @param appProvider - Fusion app module provider for fallback manifest data.
+   */
   constructor(eventProvider: IEventModuleProvider, appProvider: AppModuleProvider) {
     super('app-loaded', eventSchema);
     this.#eventProvider = eventProvider;

package/src/collectors/AppSelectedCollector.ts

@@ -11,14 +11,23 @@ import type { AppModuleProvider } from '@equinor/fusion-framework-module-app';
 
 import { z } from 'zod';
 
-/**
- * The schema of the data to be sent.
- */
+/** Zod schema for the `app-selected` event (value + attributes). */
 const eventSchema = createSchema(appKeySchema, z.object({ previous: appKeySchema }));
 
 /**
- * Collector to listen for app selection and add values and attributes for
- * further processing by adapters.
+ * Collector that emits an analytics event whenever the active Fusion application changes.
+ *
+ * @remarks
+ * Listens to `AppModuleProvider.current$`, pairs consecutive values, and emits
+ * both the new and previous app key metadata.
+ *
+ * Register via:
+ * ```ts
+ * builder.setCollector('app-selected', async (args) => {
+ *   const app = await args.requireInstance('app');
+ *   return new AppSelectedCollector(app);
+ * });
+ * ```
  */
 export class AppSelectedCollector
   extends BaseCollector<AppKeyType, { previous?: AppKeyType }>
@@ -26,6 +35,9 @@ export class AppSelectedCollector
 {
   #appProvider: AppModuleProvider;
 
+  /**
+   * @param appProvider - Fusion app module provider to observe.
+   */
   constructor(appProvider: AppModuleProvider) {
     super('app-selected', eventSchema);
     this.#appProvider = appProvider;

package/src/collectors/BaseCollector.ts

@@ -5,7 +5,14 @@ import { from, map, type ObservableInput, Subject, type Observer, type Unsubscri
 import { z } from 'zod';
 
 /**
- * Function to create zod schema to be used when collecting
+ * Creates a Zod schema for validating {@link AnalyticsEvent} instances with
+ * typed value and attributes.
+ *
+ * @template TValue - Schema type for the event body.
+ * @template TAttr - Schema type for the event attributes.
+ * @param value - Zod schema validating the event body.
+ * @param attributes - Zod schema validating the event attributes.
+ * @returns A Zod object schema matching `{ name, value, attributes? }`.
  */
 export const createSchema = <TValue = AnyValue, TAttr = AnyValueMap>(
   value: z.ZodSchema<TValue>,
@@ -18,13 +25,35 @@ export const createSchema = <TValue = AnyValue, TAttr = AnyValueMap>(
   });
 };
 
+/** Inferred Zod schema type produced by {@link createSchema}. */
 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.
+ * Abstract base class for analytics collectors that validates events against a
+ * Zod schema before emitting.
+ *
+ * @remarks
+ * Subclasses implement {@link BaseCollector._initialize | _initialize} to return
+ * an observable of raw `{ value, attributes }` objects. `BaseCollector` wraps
+ * each emission with the collector name, validates it against the supplied schema,
+ * and publishes through an internal `Subject`.
+ *
+ * @template TValue - The event body type.
+ * @template TAttr - The event attributes type.
+ *
+ * @example
+ * ```ts
+ * class MyCollector extends BaseCollector<string, { page: string }> {
+ *   constructor() {
+ *     super('my-event', createSchema(z.string(), z.object({ page: z.string() })));
+ *   }
+ *   _initialize() {
+ *     return of({ value: 'hello', attributes: { page: '/home' } });
+ *   }
+ * }
+ * ```
  */
 export abstract class BaseCollector<
   TValue extends AnyValue,
@@ -37,13 +66,33 @@ export abstract class BaseCollector<
     z.infer<CollectorSchema<TValue, TAttr>>
   >();
 
+  /**
+   * Creates a new `BaseCollector`.
+   *
+   * @param name - Event name assigned to every emission (e.g. `'context-selected'`).
+   * @param schema - Zod schema used to validate each event before publishing.
+   */
   constructor(name: string, schema: CollectorSchema<TValue, TAttr>) {
     this.#name = name;
     this.#schema = schema;
   }
 
+  /**
+   * Returns an observable source of raw `{ value, attributes }` objects.
+   *
+   * @remarks
+   * Subclasses implement this to provide the domain-specific event stream.
+   * The base class wraps the output with the collector name and validates it.
+   *
+   * @returns An observable input of value/attribute pairs.
+   */
   abstract _initialize(): ObservableInput<{ value: TValue; attributes: TAttr }>;
 
+  /**
+   * Subscribes to the source returned by {@link BaseCollector._initialize},
+   * validates each emission with the Zod schema, and publishes through the
+   * internal subject.
+   */
   initialize(): Promise<void> | void {
     from(this._initialize())
       .pipe(
@@ -59,6 +108,12 @@ export abstract class BaseCollector<
       .subscribe(this.#subject);
   }
 
+  /**
+   * Subscribes an observer to the validated event stream.
+   *
+   * @param observer - Partial observer receiving validated events.
+   * @returns An `Unsubscribable` handle.
+   */
   subscribe(observer: Partial<Observer<z.infer<CollectorSchema<TValue, TAttr>>>>): Unsubscribable {
     return this.#subject.subscribe(observer);
   }

package/src/collectors/ContextSelectedCollector.ts

@@ -10,17 +10,28 @@ import {
   extractContextMetadata,
 } from './utils/extractContextMetadata.js';
 
-/**
- * The schema of the data to be sent.
- */
+/** Zod schema for the `context-selected` event (value + attributes). */
 const eventSchema = createSchema(
   contextSchema,
   z.object({ previous: contextSchema, appKey: z.string().optional() }),
 );
 
 /**
- * Collector to listen for context changes and add values and attributes for
- * further processing by adapters.
+ * Collector that emits an analytics event whenever the active Fusion context changes.
+ *
+ * @remarks
+ * Listens to `IContextProvider.currentContext$`, de-duplicates by context ID,
+ * pairs consecutive values, and emits both the new and previous context
+ * metadata. The current application key is included in attributes.
+ *
+ * Register via:
+ * ```ts
+ * builder.setCollector('context-selected', async (args) => {
+ *   const ctx = await args.requireInstance('context');
+ *   const app = await args.requireInstance('app');
+ *   return new ContextSelectedCollector(ctx, app);
+ * });
+ * ```
  */
 export class ContextSelectedCollector
   extends BaseCollector<ContextItemType, { previous?: ContextItemType; appKey?: string }>
@@ -29,6 +40,10 @@ export class ContextSelectedCollector
   #contextProvider: IContextProvider;
   #appProvider: AppModuleProvider;
 
+  /**
+   * @param contextProvider - Fusion context module provider to observe.
+   * @param appProvider - Fusion app module provider for the current app key.
+   */
   constructor(contextProvider: IContextProvider, appProvider: AppModuleProvider) {
     super('context-selected', eventSchema);
     this.#contextProvider = contextProvider;

package/src/collectors/index.ts

@@ -1,3 +1,11 @@
+/**
+ * Re-exports for built-in analytics collectors.
+ *
+ * @remarks
+ * Import from `'@equinor/fusion-framework-module-analytics/collectors'`.
+ *
+ * @packageDocumentation
+ */
 export { IAnalyticsCollector } from './AnalyticsCollector.interface.js';
 export { ContextSelectedCollector } from './ContextSelectedCollector.js';
 export { AppSelectedCollector } from './AppSelectedCollector.js';

package/src/collectors/utils/extractAppMetadata.ts

@@ -1,8 +1,12 @@
 import { z } from 'zod';
 import type { AppManifest, CurrentApp } from '@equinor/fusion-framework-module-app';
 
-// Schema representing an object with key appKey and a string value.
-// Used to parse an object containing appKey.
+/**
+ * Zod schema for an object containing an optional `appKey` string.
+ *
+ * @remarks
+ * Used by {@link AppSelectedCollector} to validate the event body.
+ */
 export const appKeySchema = z
   .object({
     appKey: z.string().optional(),
@@ -10,8 +14,13 @@ export const appKeySchema = z
   .optional()
   .nullable();
 
-// Schema representing an object with data points of an app.
-// Used to parse an object with app data.
+/**
+ * Zod schema for a Fusion application metadata object.
+ *
+ * @remarks
+ * Validates core app fields (appKey, displayName, type) and optional build
+ * and category information. Used by {@link AppLoadedCollector}.
+ */
 export const appSchema = z
   .object({
     appKey: z.string(),
@@ -23,16 +32,30 @@ export const appSchema = z
   })
   .optional();
 
+/** Inferred type from {@link appKeySchema}. */
 export type AppKeyType = z.infer<typeof appKeySchema>;
 
+/** Inferred type from {@link appSchema}. */
 export type AppItemType = z.infer<typeof appSchema>;
 
+/**
+ * Extracts app-key metadata from a `CurrentApp` instance.
+ *
+ * @param app - The current app object.
+ * @returns An object containing the optional `appKey`.
+ */
 export const extractAppKeyMetadata = (app: CurrentApp): z.input<typeof appKeySchema> => {
   return {
     appKey: app?.appKey,
   };
 };
 
+/**
+ * Extracts detailed app metadata from an `AppManifest` for analytics events.
+ *
+ * @param app - The application manifest.
+ * @returns An object with appKey, displayName, type, and optional build/category info.
+ */
 export const extractAppMetadata = (app: AppManifest): z.input<typeof appSchema> => {
   return {
     appKey: app.appKey,

package/src/collectors/utils/extractContextMetadata.ts

@@ -1,8 +1,13 @@
 import { z } from 'zod';
 import type { ContextItem } from '@equinor/fusion-framework-module-context';
 
-// Schema representing an object with data points of a Fusion context.
-// Used to parse an object with context data.
+/**
+ * Zod schema for a Fusion context metadata object.
+ *
+ * @remarks
+ * Validates core context fields (id, type) and optional title, externalId,
+ * and source. Used by {@link ContextSelectedCollector} and {@link AppLoadedCollector}.
+ */
 export const contextSchema = z
   .object({
     id: z.string(),
@@ -14,8 +19,15 @@ export const contextSchema = z
   .optional()
   .nullable();
 
+/** Inferred type from {@link contextSchema}. */
 export type ContextItemType = z.infer<typeof contextSchema>;
 
+/**
+ * Extracts context metadata from a `ContextItem` for analytics events.
+ *
+ * @param context - The Fusion context item.
+ * @returns An object with id, type, and optional title, externalId, and source.
+ */
 export const extractContextMetadata = (context: ContextItem): z.input<typeof contextSchema> => {
   return {
     id: context.id,

package/src/enable-analytics.ts

@@ -3,13 +3,29 @@ import type { IModulesConfigurator } from '@equinor/fusion-framework-module';
 import { module } from './module.js';
 import type { IAnalyticsConfigurator } from './AnalyticsConfigurator.interface.js';
 
+/** Callback invoked with the {@link IAnalyticsConfigurator} to register adapters and collectors. */
 type AnalyticsBuilderCallback = (builder: IAnalyticsConfigurator) => void | Promise<void>;
 
 /**
- * Enables analytics for agiven module configurator.
+ * Enables the analytics module on a Fusion Framework 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.
+ * Call this helper during application or portal configuration to register
+ * adapters and collectors for analytics tracking.
+ *
+ * @param configurator - The module configurator instance to attach analytics to.
+ * @param callback - Optional callback to register adapters and collectors on the analytics builder.
+ *
+ * @example
+ * ```ts
+ * import { enableAnalytics } from '@equinor/fusion-framework-module-analytics';
+ * import { ConsoleAnalyticsAdapter } from '@equinor/fusion-framework-module-analytics/adapters';
+ *
+ * const configure = (configurator) => {
+ *   enableAnalytics(configurator, (builder) => {
+ *     builder.setAdapter('console', async () => new ConsoleAnalyticsAdapter());
+ *   });
+ * };
+ * ```
  */
 export const enableAnalytics = (
   // biome-ignore lint/suspicious/noExplicitAny: must be any to support all module types

package/src/index.ts

@@ -1,3 +1,22 @@
+/**
+ * `@equinor/fusion-framework-module-analytics` — Fusion Framework module for
+ * collecting and exporting application analytics using OpenTelemetry standards.
+ *
+ * @remarks
+ * This package provides a pluggable adapter/collector architecture:
+ *
+ * - **Adapters** receive analytics events and forward them to a backend
+ *   (e.g. console, OTLP endpoint).
+ * - **Collectors** observe application state (context changes, app loads) and
+ *   emit structured {@link AnalyticsEvent} instances.
+ *
+ * Import adapters from `'@equinor/fusion-framework-module-analytics/adapters'`,
+ * collectors from `'@equinor/fusion-framework-module-analytics/collectors'`,
+ * and log exporters from `'@equinor/fusion-framework-module-analytics/logExporters'`.
+ *
+ * @packageDocumentation
+ */
+
 export { module as analyticsModule, AnalyticsModule } from './module.js';
 
 export { AnalyticsEvent, AnyValue, AnyValueMap } from './types.js';

package/src/logExporters/fusionOTLPLogExporter/FusionOTLPLogExporter.ts

@@ -11,7 +11,11 @@ import {
 import type { IHttpClient } from '@equinor/fusion-framework-module-http';
 import { HttpClientExporterTransport } from './HttpClientExporterTransport.js';
 
-// The shared default configuration needed for the OTLPNetworkExportDelegate
+/**
+ * Returns shared default OTLP exporter configuration values.
+ *
+ * @returns Default timeout, concurrency limit, and compression settings.
+ */
 function getSharedConfigurationDefaults(): OtlpSharedConfiguration {
   return {
     timeoutMillis: 10000,
@@ -21,14 +25,32 @@ function getSharedConfigurationDefaults(): OtlpSharedConfiguration {
 }
 
 /**
- * A log exporter extending OTLPExporterBase but substitute the normal transport
- * with a HttpClientExporterTransport. This will use the provided httpClient to
- * emit the event.
+ * OTLP log exporter that uses a Fusion `IHttpClient` as its HTTP transport.
+ *
+ * @remarks
+ * Extends `OTLPExporterBase` and substitutes the default `fetch`-based transport
+ * with {@link HttpClientExporterTransport}, routing log record payloads
+ * through the Fusion HTTP module’s configured client (which may include
+ * authentication headers, interceptors, and service‑discovery routing).
+ *
+ * Typically used with {@link FusionAnalyticsAdapter} when the portal provides
+ * an HTTP client via service discovery.
+ *
+ * @example
+ * ```ts
+ * import { FusionOTLPLogExporter } from '@equinor/fusion-framework-module-analytics/logExporters';
+ *
+ * const httpClient = await serviceDiscovery.createClient('analytics');
+ * const exporter = new FusionOTLPLogExporter(httpClient);
+ * ```
  */
 export class FusionOTLPLogExporter
   extends OTLPExporterBase<ReadableLogRecord[]>
   implements LogRecordExporter
 {
+  /**
+   * @param httpClient - A Fusion `IHttpClient` used for outbound HTTP transport.
+   */
   constructor(httpClient: IHttpClient) {
     super(
       createOtlpNetworkExportDelegate(

package/src/logExporters/fusionOTLPLogExporter/HttpClientExporterTransport.ts

@@ -2,6 +2,12 @@ import type { IExporterTransport, ExportResponse } from '@opentelemetry/otlp-exp
 
 import type { IHttpClient } from '@equinor/fusion-framework-module-http';
 
+/**
+ * Checks whether a failed HTTP status code is eligible for automatic retry.
+ *
+ * @param statusCode - HTTP response status code.
+ * @returns `true` for 429, 502, 503, and 504.
+ */
 function isExportRetryable(statusCode: number): boolean {
   // Status codes of when we should consider retrying.
   // 429 Too Many Requests
@@ -12,7 +18,12 @@ function isExportRetryable(statusCode: number): boolean {
   return retryCodes.includes(statusCode);
 }
 
-// Parse the `Retry-After` header and return when the service will allow a retry.
+/**
+ * Parses an HTTP `Retry-After` header value into milliseconds.
+ *
+ * @param retryAfter - Raw header value (integer seconds or HTTP-date).
+ * @returns Delay in milliseconds, `-1` for non-positive integers, or `undefined` if absent.
+ */
 function parseRetryAfterToMills(retryAfter?: string | undefined | null): number | undefined {
   if (retryAfter == null) {
     return undefined;
@@ -32,19 +43,36 @@ function parseRetryAfterToMills(retryAfter?: string | undefined | null): number
 }
 
 /**
- * A Exporter Transport to POST events to provided path using the provided httpClient
+ * OpenTelemetry exporter transport that posts serialised log records using a
+ * Fusion `IHttpClient`.
+ *
+ * @remarks
+ * Implements `IExporterTransport` from `@opentelemetry/otlp-exporter-base`.
+ * The transport honours the exporter’s timeout via `AbortController` and
+ * inspects response status codes to report retryable failures (429, 502–504).
+ *
+ * @example
+ * ```ts
+ * const transport = new HttpClientExporterTransport(httpClient, '/v1/logs');
+ * ```
  */
 export class HttpClientExporterTransport implements IExporterTransport {
+  /**
+   * @param httpClient - Fusion HTTP client for outgoing requests.
+   * @param path - URL path appended to the client’s base URL (default `'/v1/logs'`).
+   */
   constructor(
     private httpClient: IHttpClient,
     private path: string = '/v1/logs',
   ) {}
 
-  // Will send data with the httpClient.
-  // If the service responds with a non 2** statusCode, we check if it is
-  // retryable.
-  // The timeoutMillis determines when to abort if the service has not yet
-  // responded.
+  /**
+   * Sends serialised log record data to the configured endpoint.
+   *
+   * @param data - Serialised OTLP payload as a `Uint8Array`.
+   * @param timeoutMillis - Maximum time in milliseconds before the request is aborted.
+   * @returns An `ExportResponse` indicating success, retryable failure, or permanent failure.
+   */
   async send(data: Uint8Array, timeoutMillis: number): Promise<ExportResponse> {
     const abortController = new AbortController();
     const timeout = setTimeout(() => abortController.abort(), timeoutMillis);
@@ -83,6 +111,7 @@ export class HttpClientExporterTransport implements IExporterTransport {
       clearTimeout(timeout);
     }
   }
+  /** No-op; the HTTP client does not hold persistent connections. */
   shutdown(): void {
     // intentionally left empty, nothing to do.
   }

package/src/logExporters/index.ts

@@ -1,2 +1,10 @@
+/**
+ * Re-exports for OTLP log exporters used by analytics adapters.
+ *
+ * @remarks
+ * Import from `'@equinor/fusion-framework-module-analytics/logExporters'`.
+ *
+ * @packageDocumentation
+ */
 export { FusionOTLPLogExporter } from './fusionOTLPLogExporter/FusionOTLPLogExporter.js';
 export { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';