launchdarkly-js-sdk-common 5.5.0 → 5.6.0-beta.1

package/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "5.5.0"
+  ".": "5.5.1"
 }

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All notable changes to the `launchdarkly-js-sdk-common` package will be documented in this file. Changes that affect the dependent SDKs such as `launchdarkly-js-client-sdk` should also be logged in those projects, in the next release that uses the updated version of this package. This project adheres to [Semantic Versioning](http://semver.org).
 
+## [5.5.1](https://github.com/launchdarkly/js-sdk-common/compare/5.5.0...5.5.1) (2025-04-25)
+
+
+### Bug Fixes
+
+* Add hooks to default options to prevent warning. ([#121](https://github.com/launchdarkly/js-sdk-common/issues/121)) ([9c04081](https://github.com/launchdarkly/js-sdk-common/commit/9c04081e828d2dde84f800c139480e960b537cfe))
+
 ## [5.5.0](https://github.com/launchdarkly/js-sdk-common/compare/5.4.0...5.5.0) (2025-04-21)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "launchdarkly-js-sdk-common",
-  "version": "5.5.0",
+  "version": "5.6.0-beta.1",
   "description": "LaunchDarkly SDK for JavaScript - common code",
   "author": "LaunchDarkly <team@launchdarkly.com>",
   "license": "Apache-2.0",

package/src/HookRunner.js

@@ -3,6 +3,7 @@ const BEFORE_EVALUATION_STAGE_NAME = 'beforeEvaluation';
 const AFTER_EVALUATION_STAGE_NAME = 'afterEvaluation';
 const BEFORE_IDENTIFY_STAGE_NAME = 'beforeIdentify';
 const AFTER_IDENTIFY_STAGE_NAME = 'afterIdentify';
+const AFTER_TRACK_STAGE_NAME = 'afterTrack';
 
 /**
  * Safely executes a hook stage function, logging any errors.
@@ -125,6 +126,28 @@ function executeAfterIdentify(logger, hooks, hookContext, updatedData, result) {
   }
 }
 
+/**
+ * Executes the 'afterTrack' stage for all registered hooks in reverse order.
+ * @param {{ error: (message: string) => void }} logger The logger instance.
+ * @param {Array<{ afterTrack?: (hookContext: { context: object, data: object, metricValue: number }) => void }>} hooks The array of hook instances.
+ * @param {{ context: object, data: object, metricValue: number }} hookContext The context for the track operation.
+ * @returns {void}
+ */
+function executeAfterTrack(logger, hooks, hookContext) {
+  // This iterates in reverse, versus reversing a shallow copy of the hooks,
+  // for efficiency.
+  for (let hookIndex = hooks.length - 1; hookIndex >= 0; hookIndex -= 1) {
+    const hook = hooks[hookIndex];
+    tryExecuteStage(
+      logger,
+      AFTER_TRACK_STAGE_NAME,
+      getHookName(logger, hook),
+      () => hook?.afterTrack?.(hookContext),
+      undefined
+    );
+  }
+}
+
 /**
  * Factory function to create a HookRunner instance.
  * Manages the execution of hooks for flag evaluations and identify operations.
@@ -203,10 +226,24 @@ function createHookRunner(logger, initialHooks) {
     hooksInternal.push(hook);
   }
 
+  /**
+   * Executes the 'afterTrack' stage for all registered hooks in reverse order.
+   * @param {{ context: object, data: object, metricValue: number }} hookContext The context for the track operation.
+   * @returns {void}
+   */
+  function afterTrack(hookContext) {
+    if (hooksInternal.length === 0) {
+      return;
+    }
+    const hooks = [...hooksInternal];
+    executeAfterTrack(logger, hooks, hookContext);
+  }
+
   return {
     withEvaluation,
     identify,
     addHook,
+    afterTrack,
   };
 }
 

package/src/__tests__/HookRunner-test.js

@@ -16,6 +16,7 @@ const createTestHook = (name = 'Test Hook') => ({
   afterEvaluation: jest.fn(),
   beforeIdentify: jest.fn(),
   afterIdentify: jest.fn(),
+  afterTrack: jest.fn(),
 });
 
 describe('Given a logger, runner, and hook', () => {
@@ -328,4 +329,121 @@ describe('Given a logger, runner, and hook', () => {
       `An error was encountered in "beforeEvaluation" of the "${hookName}" hook: Error: Specific test error`
     );
   });
+
+  it('should execute afterTrack hooks', () => {
+    const context = { kind: 'user', key: 'user-123' };
+    const key = 'test';
+    const data = { test: 'data' };
+    const metricValue = 42;
+
+    const trackContext = {
+      key,
+      context,
+      data,
+      metricValue,
+    };
+
+    hookRunner.afterTrack(trackContext);
+
+    expect(testHook.afterTrack).toHaveBeenCalledWith(trackContext);
+  });
+
+  it('should handle errors in afterTrack hooks', () => {
+    const errorHook = {
+      getMetadata: jest.fn().mockReturnValue({ name: 'Error Hook' }),
+      afterTrack: jest.fn().mockImplementation(() => {
+        throw new Error('Hook error');
+      }),
+    };
+
+    const errorHookRunner = createHookRunner(logger, [errorHook]);
+
+    errorHookRunner.afterTrack({
+      key: 'test',
+      context: { kind: 'user', key: 'user-123' },
+    });
+
+    expect(logger.error).toHaveBeenCalledWith(
+      expect.stringContaining('An error was encountered in "afterTrack" of the "Error Hook" hook: Error: Hook error')
+    );
+  });
+
+  it('should skip afterTrack execution if there are no hooks', () => {
+    const emptyHookRunner = createHookRunner(logger, []);
+
+    emptyHookRunner.afterTrack({
+      key: 'test',
+      context: { kind: 'user', key: 'user-123' },
+    });
+
+    expect(logger.error).not.toHaveBeenCalled();
+  });
+
+  it('executes hook stages in the specified order', () => {
+    const beforeEvalOrder = [];
+    const afterEvalOrder = [];
+    const beforeIdentifyOrder = [];
+    const afterIdentifyOrder = [];
+    const afterTrackOrder = [];
+
+    const createMockHook = id => ({
+      getMetadata: jest.fn().mockReturnValue({ name: `Hook ${id}` }),
+      beforeEvaluation: jest.fn().mockImplementation((_context, data) => {
+        beforeEvalOrder.push(id);
+        return data;
+      }),
+      afterEvaluation: jest.fn().mockImplementation((_context, data) => {
+        afterEvalOrder.push(id);
+        return data;
+      }),
+      beforeIdentify: jest.fn().mockImplementation((_context, data) => {
+        beforeIdentifyOrder.push(id);
+        return data;
+      }),
+      afterIdentify: jest.fn().mockImplementation((_context, data) => {
+        afterIdentifyOrder.push(id);
+        return data;
+      }),
+      afterTrack: jest.fn().mockImplementation(() => {
+        afterTrackOrder.push(id);
+      }),
+    });
+
+    const hookA = createMockHook('a');
+    const hookB = createMockHook('b');
+    const hookC = createMockHook('c');
+
+    const runner = createHookRunner(logger, [hookA, hookB]);
+    runner.addHook(hookC);
+
+    // Test evaluation order
+    runner.withEvaluation('flagKey', { kind: 'user', key: 'bob' }, 'default', () => ({
+      value: false,
+      reason: { kind: 'ERROR', errorKind: 'FLAG_NOT_FOUND' },
+      variationIndex: null,
+    }));
+
+    // Test identify order
+    const identifyCallback = runner.identify({ kind: 'user', key: 'bob' }, 1000);
+    identifyCallback({ status: 'completed' });
+
+    // Test track order
+    runner.afterTrack({
+      key: 'test',
+      context: { kind: 'user', key: 'bob' },
+      data: { test: 'data' },
+      metricValue: 42,
+    });
+
+    // Verify evaluation hooks order
+    expect(beforeEvalOrder).toEqual(['a', 'b', 'c']);
+    expect(afterEvalOrder).toEqual(['c', 'b', 'a']);
+
+    // Verify identify hooks order
+    expect(beforeIdentifyOrder).toEqual(['a', 'b', 'c']);
+    expect(afterIdentifyOrder).toEqual(['c', 'b', 'a']);
+
+    // Verify track hooks order
+    expect(afterTrackOrder).toEqual(['c', 'b', 'a']);
+  });
 });

package/src/__tests__/LDClient-hooks-test.js

@@ -225,4 +225,30 @@ describe('LDClient Hooks Integration', () => {
       });
     });
   });
+
+  it('should execute afterTrack hooks when tracking events', async () => {
+    const testHook = {
+      beforeEvaluation: jest.fn(),
+      afterEvaluation: jest.fn(),
+      beforeIdentify: jest.fn(),
+      afterIdentify: jest.fn(),
+      afterTrack: jest.fn(),
+      getMetadata() {
+        return {
+          name: 'test hook',
+        };
+      },
+    };
+
+    await withClient(initialContext, {}, [testHook], async client => {
+      client.track('test', { test: 'data' }, 42);
+
+      expect(testHook.afterTrack).toHaveBeenCalledWith({
+        key: 'test',
+        context: { kind: 'user', key: 'user-key-initial' },
+        data: { test: 'data' },
+        metricValue: 42,
+      });
+    });
+  });
 });

package/src/__tests__/LDClient-plugins-test.js

@@ -0,0 +1,214 @@
+const { initialize } = require('../index');
+const stubPlatform = require('./stubPlatform');
+const { respondJson } = require('./mockHttp');
+
+// Mock the logger functions
+const mockLogger = () => ({
+  error: jest.fn(),
+  warn: jest.fn(),
+  info: jest.fn(),
+  debug: jest.fn(),
+});
+
+// Define a basic Hook structure for tests
+const createTestHook = (name = 'Test Hook') => ({
+  getMetadata: jest.fn().mockReturnValue({ name }),
+  beforeEvaluation: jest.fn().mockImplementation((_ctx, data) => data),
+  afterEvaluation: jest.fn().mockImplementation((_ctx, data) => data),
+  beforeIdentify: jest.fn().mockImplementation((_ctx, data) => data),
+  afterIdentify: jest.fn().mockImplementation((_ctx, data) => data),
+  afterTrack: jest.fn().mockImplementation((_ctx, data) => data),
+});
+
+// Define a basic Plugin structure for tests
+const createTestPlugin = (name = 'Test Plugin', hooks = []) => ({
+  getMetadata: jest.fn().mockReturnValue({ name }),
+  register: jest.fn(),
+  getHooks: jest.fn().mockReturnValue(hooks),
+});
+
+// Helper to initialize the client for tests
+async function withClient(initialContext, configOverrides = {}, plugins = [], testFn) {
+  const platform = stubPlatform.defaults();
+  const server = platform.testing.http.newServer();
+  const logger = mockLogger();
+
+  // Disable streaming and event sending unless overridden
+  const defaults = {
+    baseUrl: server.url,
+    streaming: false,
+    sendEvents: false,
+    useLdd: false,
+    logger: logger,
+    plugins: plugins,
+  };
+  const config = { ...defaults, ...configOverrides };
+  const { client, start } = initialize('env', initialContext, config, platform);
+
+  server.byDefault(respondJson({}));
+  start();
+
+  try {
+    await client.waitForInitialization(10);
+    await testFn(client, logger, platform);
+  } finally {
+    await client.close();
+    server.close();
+  }
+}
+
+it('registers plugins and executes hooks during initialization', async () => {
+  const mockHook = createTestHook('test-hook');
+  const mockPlugin = createTestPlugin('test-plugin', [mockHook]);
+
+  await withClient({ key: 'user-key', kind: 'user' }, {}, [mockPlugin], async client => {
+    // Verify the plugin was registered
+    expect(mockPlugin.register).toHaveBeenCalled();
+
+    // Test identify hook
+    await client.identify({ key: 'user-key', kind: 'user' });
+    expect(mockHook.beforeIdentify).toHaveBeenCalledWith(
+      { context: { key: 'user-key', kind: 'user' }, timeout: undefined },
+      {}
+    );
+    expect(mockHook.afterIdentify).toHaveBeenCalledWith(
+      { context: { key: 'user-key', kind: 'user' }, timeout: undefined },
+      {},
+      { status: 'completed' }
+    );
+
+    // Test variation hook
+    client.variation('flag-key', false);
+    expect(mockHook.beforeEvaluation).toHaveBeenCalledWith(
+      {
+        context: { key: 'user-key', kind: 'user' },
+        defaultValue: false,
+        flagKey: 'flag-key',
+      },
+      {}
+    );
+    expect(mockHook.afterEvaluation).toHaveBeenCalled();
+
+    // Test track hook
+    client.track('event-key', { data: true }, 42);
+    expect(mockHook.afterTrack).toHaveBeenCalledWith({
+      context: { key: 'user-key', kind: 'user' },
+      key: 'event-key',
+      data: { data: true },
+      metricValue: 42,
+    });
+  });
+});
+
+it('registers multiple plugins and executes all hooks', async () => {
+  const mockHook1 = createTestHook('test-hook-1');
+  const mockHook2 = createTestHook('test-hook-2');
+  const mockPlugin1 = createTestPlugin('test-plugin-1', [mockHook1]);
+  const mockPlugin2 = createTestPlugin('test-plugin-2', [mockHook2]);
+
+  await withClient({ key: 'user-key', kind: 'user' }, {}, [mockPlugin1, mockPlugin2], async client => {
+    // Verify plugins were registered
+    expect(mockPlugin1.register).toHaveBeenCalled();
+    expect(mockPlugin2.register).toHaveBeenCalled();
+
+    // Test that both hooks work
+    await client.identify({ key: 'user-key', kind: 'user' });
+    client.variation('flag-key', false);
+    client.track('event-key', { data: true }, 42);
+
+    expect(mockHook1.beforeEvaluation).toHaveBeenCalled();
+    expect(mockHook1.afterEvaluation).toHaveBeenCalled();
+    expect(mockHook2.beforeEvaluation).toHaveBeenCalled();
+    expect(mockHook2.afterEvaluation).toHaveBeenCalled();
+    expect(mockHook1.afterTrack).toHaveBeenCalled();
+    expect(mockHook2.afterTrack).toHaveBeenCalled();
+  });
+});
+
+it('passes correct environmentMetadata to plugin getHooks and register functions', async () => {
+  const mockPlugin = createTestPlugin('test-plugin');
+  const options = {
+    wrapperName: 'test-wrapper',
+    wrapperVersion: '2.0.0',
+    application: {
+      name: 'test-app',
+      version: '3.0.0',
+    },
+  };
+
+  await withClient(
+    { key: 'user-key', kind: 'user' },
+    { ...options, plugins: [mockPlugin] },
+    [mockPlugin],
+    async (client, logger, testPlatform) => {
+      expect(testPlatform.userAgent).toBeDefined();
+      expect(testPlatform.version).toBeDefined();
+      // Verify getHooks was called with correct environmentMetadata
+      expect(mockPlugin.getHooks).toHaveBeenCalledWith({
+        sdk: {
+          name: testPlatform.userAgent,
+          version: testPlatform.version,
+          wrapperName: options.wrapperName,
+          wrapperVersion: options.wrapperVersion,
+        },
+        application: {
+          id: options.application.id,
+          version: options.application.version,
+        },
+        clientSideId: 'env',
+      });
+
+      // Verify register was called with correct environmentMetadata
+      expect(mockPlugin.register).toHaveBeenCalledWith(
+        expect.any(Object), // client
+        {
+          sdk: {
+            name: testPlatform.userAgent,
+            version: testPlatform.version,
+            wrapperName: options.wrapperName,
+            wrapperVersion: options.wrapperVersion,
+          },
+          application: {
+            id: options.application.id,
+            version: options.application.version,
+          },
+          clientSideId: 'env',
+        }
+      );
+    }
+  );
+});
+
+it('passes correct environmentMetadata without optional fields', async () => {
+  const mockPlugin = createTestPlugin('test-plugin');
+
+  await withClient(
+    { key: 'user-key', kind: 'user' },
+    { plugins: [mockPlugin] },
+    [mockPlugin],
+    async (client, logger, testPlatform) => {
+      expect(testPlatform.userAgent).toBeDefined();
+      expect(testPlatform.version).toBeDefined();
+      // Verify getHooks was called with correct environmentMetadata
+      expect(mockPlugin.getHooks).toHaveBeenCalledWith({
+        sdk: {
+          name: testPlatform.userAgent,
+          version: testPlatform.version,
+        },
+        clientSideId: 'env',
+      });
+
+      // Verify register was called with correct environmentMetadata
+      expect(mockPlugin.register).toHaveBeenCalledWith(
+        expect.any(Object), // client
+        {
+          sdk: {
+            name: testPlatform.userAgent,
+            version: testPlatform.version,
+          },
+          clientSideId: 'env',
+        }
+      );
+    }
+  );
+});

package/src/configuration.js

@@ -37,6 +37,8 @@ const baseOptionDefs = {
   stateProvider: { type: 'object' }, // not a public option, used internally
   application: { validator: applicationConfigValidator },
   inspectors: { default: [] },
+  hooks: { default: [] },
+  plugins: { default: [] },
 };
 
 /**

package/src/index.js

@@ -18,7 +18,7 @@ const { checkContext, getContextKeys } = require('./context');
 const { InspectorTypes, InspectorManager } = require('./InspectorManager');
 const timedPromise = require('./timedPromise');
 const createHookRunner = require('./HookRunner');
-
+const { getPluginHooks, registerPlugins, createPluginEnvironment } = require('./plugins');
 const changeEvent = 'change';
 const internalChangeEvent = 'internal-change';
 const highTimeoutThreshold = 5;
@@ -41,7 +41,13 @@ function initialize(env, context, specifiedOptions, platform, extraOptionDefs) {
   const sendEvents = options.sendEvents;
   let environment = env;
   let hash = options.hash;
-  const hookRunner = createHookRunner(logger, options.hooks);
+  const plugins = [...options.plugins];
+
+  const pluginEnvironment = createPluginEnvironment(platform, env, options);
+
+  const pluginHooks = getPluginHooks(logger, pluginEnvironment, plugins);
+
+  const hookRunner = createHookRunner(logger, [...options.hooks, ...pluginHooks]);
 
   const persistentStorage = PersistentStorage(platform.localStorage, logger);
 
@@ -428,6 +434,7 @@ function initialize(env, context, specifiedOptions, platform, extraOptionDefs) {
       e.metricValue = metricValue;
     }
     enqueueEvent(e);
+    hookRunner.afterTrack({ context, key, data, metricValue });
   }
 
   function connectStream() {
@@ -871,6 +878,8 @@ function initialize(env, context, specifiedOptions, platform, extraOptionDefs) {
     addHook: addHook,
   };
 
+  registerPlugins(logger, pluginEnvironment, client, plugins);
+
   return {
     client: client, // The client object containing all public methods.
     options: options, // The validated configuration object, including all defaults.

package/src/plugins.js

@@ -0,0 +1,109 @@
+const UNKNOWN_PLUGIN_NAME = 'unknown plugin';
+
+/**
+ * Safely gets the name of a plugin with error handling
+ * @param {{ error: (message: string) => void }} logger - The logger instance
+ * @param {{getMetadata: () => {name: string}}} plugin - Plugin object that may have a name property
+ * @returns {string} The plugin name or 'unknown' if not available
+ */
+function getPluginName(logger, plugin) {
+  try {
+    return plugin.getMetadata().name || UNKNOWN_PLUGIN_NAME;
+  } catch (error) {
+    logger.error(`Exception thrown getting metadata for plugin. Unable to get plugin name.`);
+    return UNKNOWN_PLUGIN_NAME;
+  }
+}
+
+/**
+ * Safely retrieves hooks from plugins with error handling
+ * @param {Object} logger - The logger instance
+ * @param {Object} environmentMetadata - Metadata about the environment for plugin initialization
+ * @param {Array<{getHooks: (environmentMetadata: object) => Hook[]}>} plugins - Array of plugin objects that may implement getHooks
+ * @returns {Array<Hook>} Array of hook objects collected from all plugins
+ */
+function getPluginHooks(logger, environmentMetadata, plugins) {
+  const hooks = [];
+  plugins.forEach(plugin => {
+    try {
+      const pluginHooks = plugin.getHooks?.(environmentMetadata);
+      if (pluginHooks === undefined) {
+        logger.error(`Plugin ${getPluginName(logger, plugin)} returned undefined from getHooks.`);
+      } else if (pluginHooks && pluginHooks.length > 0) {
+        hooks.push(...pluginHooks);
+      }
+    } catch (error) {
+      logger.error(`Exception thrown getting hooks for plugin ${getPluginName(logger, plugin)}. Unable to get hooks.`);
+    }
+  });
+  return hooks;
+}
+
+/**
+ * Registers plugins with the SDK
+ * @param {{ error: (message: string) => void }} logger - The logger instance
+ * @param {Object} environmentMetadata - Metadata about the environment for plugin initialization
+ * @param {Object} client - The SDK client instance
+ * @param {Array<{register: (client: object, environmentMetadata: object) => void}>} plugins - Array of plugin objects that implement register
+ */
+function registerPlugins(logger, environmentMetadata, client, plugins) {
+  plugins.forEach(plugin => {
+    try {
+      plugin.register(client, environmentMetadata);
+    } catch (error) {
+      logger.error(`Exception thrown registering plugin ${getPluginName(logger, plugin)}.`);
+    }
+  });
+}
+
+/**
+ * Creates a plugin environment object
+ * @param {{userAgent: string, version: string}} platform - The platform object
+ * @param {string} env - The environment
+ * @param {{application: {name: string, version: string}, wrapperName: string, wrapperVersion: string}} options - The options
+ * @returns {{sdk: {name: string, version: string, wrapperName: string, wrapperVersion: string}, application: {name: string, version: string}, clientSideId: string}} The plugin environment
+ */
+function createPluginEnvironment(platform, env, options) {
+  const pluginSdkMetadata = {};
+
+  if (platform.userAgent) {
+    pluginSdkMetadata.name = platform.userAgent;
+  }
+  if (platform.version) {
+    pluginSdkMetadata.version = platform.version;
+  }
+  if (options.wrapperName) {
+    pluginSdkMetadata.wrapperName = options.wrapperName;
+  }
+  if (options.wrapperVersion) {
+    pluginSdkMetadata.wrapperVersion = options.wrapperVersion;
+  }
+
+  const pluginApplicationMetadata = {};
+
+  if (options.application) {
+    if (options.application.name) {
+      pluginApplicationMetadata.name = options.application.name;
+    }
+    if (options.application.version) {
+      pluginApplicationMetadata.version = options.application.version;
+    }
+  }
+
+  const pluginEnvironment = {
+    sdk: pluginSdkMetadata,
+    clientSideId: env,
+  };
+
+  if (Object.keys(pluginApplicationMetadata).length > 0) {
+    pluginEnvironment.application = pluginApplicationMetadata;
+  }
+
+  return pluginEnvironment;
+}
+
+module.exports = {
+  getPluginHooks,
+  registerPlugins,
+  createPluginEnvironment,
+};

package/test-types.ts

@@ -27,6 +27,40 @@ var user: ld.LDContext = {
   },
   privateAttributeNames: [ 'name', 'email' ]
 };
+const hook: ld.Hook = {
+  getMetadata: () => ({
+    name: 'hook',
+  }),
+
+  beforeEvaluation(hookContext: ld.EvaluationSeriesContext, data: ld.EvaluationSeriesData): ld.EvaluationSeriesData {
+    return data;
+  },
+  afterEvaluation(hookContext: ld.EvaluationSeriesContext, data: ld.EvaluationSeriesData, detail: ld.LDEvaluationDetail): ld.EvaluationSeriesData {
+    return data;
+  },
+  beforeIdentify(hookContext: ld.IdentifySeriesContext, data: ld.IdentifySeriesData): ld.IdentifySeriesData {
+    return data;
+  },
+  afterIdentify(hookContext: ld.IdentifySeriesContext, data: ld.IdentifySeriesData, result: ld.IdentifySeriesResult): ld.IdentifySeriesData {
+    return data;
+  },
+
+  afterTrack(hookContext: ld.TrackSeriesContext): void {
+  }
+};
+
+const plugin: ld.LDPlugin = {
+  getMetadata: () => ({
+    name: 'plugin',
+  }),
+  register(client: ld.LDClientBase, environmentMetadata: ld.LDPluginEnvironmentMetadata): void {
+  },
+
+  getHooks(metadata: ld.LDPluginEnvironmentMetadata): ld.Hook[] {
+    return [];
+  },
+};
+
 var logger: ld.LDLogger = ld.commonBasicLogger({ level: 'info' });
 var allBaseOptions: ld.LDOptionsBase = {
   bootstrap: { },
@@ -48,7 +82,9 @@ var allBaseOptions: ld.LDOptionsBase = {
   application: {
     version: 'version',
     id: 'id'
-  }
+  },
+  hooks: [ hook ],
+  plugins: [ plugin ]
 };
 
 var client: ld.LDClientBase = {} as ld.LDClientBase;  // wouldn't do this in real life, it's just so the following statements will compile

package/typings.d.ts

@@ -127,6 +127,29 @@ declare module 'launchdarkly-js-sdk-common' {
     status: IdentifySeriesStatus;
   }
 
+  /**
+   * Contextual information provided to track stages.
+   */
+  export interface TrackSeriesContext {
+    /**
+     * The key for the event being tracked.
+     */
+    readonly key: string;
+    /**
+     * The context associated with the track operation.
+     */
+    readonly context: LDContext;
+    /**
+     * The data associated with the track operation.
+     */
+    readonly data?: unknown;
+    /**
+     * The metric value associated with the track operation.
+     */
+    readonly metricValue?: number;
+  }
+
+
   /**
    * Interface for extending SDK functionality via hooks.
    */
@@ -216,8 +239,132 @@ declare module 'launchdarkly-js-sdk-common' {
       data: IdentifySeriesData,
       result: IdentifySeriesResult,
     ): IdentifySeriesData;
+
+    /**
+     * This method is called during the execution of the track process after the event
+     * has been enqueued.
+     *
+     * @param hookContext Contains information about the track operation being performed. This is not
+     *  mutable.
+     */
+    afterTrack?(hookContext: TrackSeriesContext): void;
+  }
+
+  /**
+   * Meta-data about a plugin implementation.
+   *
+   * May be used in logs and analytics to identify the plugin.
+   */
+  export interface LDPluginMetadata {
+    /**
+     * The name of the plugin.
+     */
+    readonly name: string;
+  }
+
+  /**
+  * Metadata about the SDK that is running the plugin.
+  */
+  export interface LDPluginSdkMetadata {
+    /**
+     * The name of the SDK.
+     */
+    readonly name: string;
+
+    /**
+     * The version of the SDK.
+     */
+    readonly version: string;
+
+    /**
+     * If this is a wrapper SDK, then this is the name of the wrapper.
+     */
+    readonly wrapperName?: string;
+
+    /**
+     * If this is a wrapper SDK, then this is the version of the wrapper.
+     */
+    readonly wrapperVersion?: string;
+  }
+
+  /**
+  * Metadata about the application where the LaunchDarkly SDK is running.
+  */
+  export interface LDPluginApplicationMetadata {
+    /**
+     * A unique identifier representing the application where the LaunchDarkly SDK is running.
+     *
+     * This can be specified as any string value as long as it only uses the following characters: ASCII letters,
+     * ASCII digits, period, hyphen, underscore. A string containing any other characters will be ignored.
+     *
+     * Example: `authentication-service`
+     */
+    readonly id?: string;
+
+    /**
+     * A unique identifier representing the version of the application where the LaunchDarkly SDK is running.
+     *
+     * This can be specified as any string value as long as it only uses the following characters: ASCII letters,
+     * ASCII digits, period, hyphen, underscore. A string containing any other characters will be ignored.
+     *
+     * Example: `1.0.0` (standard version string) or `abcdef` (sha prefix)
+     */
+    readonly version?: string;
   }
 
+  /**
+  * Metadata about the environment where the plugin is running.
+  */
+  export interface LDPluginEnvironmentMetadata {
+    /**
+     * Metadata about the SDK that is running the plugin.
+     */
+    readonly sdk: LDPluginSdkMetadata;
+
+    /**
+     * Metadata about the application where the LaunchDarkly SDK is running.
+     *
+     * Only present if any application information is available.
+     */
+    readonly application?: LDPluginApplicationMetadata;
+
+    /**
+     * The client-side ID used to initialize the SDK.
+     */
+    readonly clientSideId: string;
+  }
+
+/**
+ * Interface for plugins to the LaunchDarkly SDK.
+ */
+export interface LDPlugin {
+  /**
+   * Get metadata about the plugin.
+   */
+  getMetadata(): LDPluginMetadata;
+
+  /**
+   * Registers the plugin with the SDK. Called once during SDK initialization.
+   *
+   * The SDK initialization will typically not have been completed at this point, so the plugin should take appropriate
+   * actions to ensure the SDK is ready before sending track events or evaluating flags.
+   *
+   * @param client The SDK client instance.
+   * @param environmentMetadata Information about the environment where the plugin is running.
+   */
+  register(client: LDClientBase, environmentMetadata: LDPluginEnvironmentMetadata): void;
+
+  /**
+   * Gets a list of hooks that the plugin wants to register.
+   *
+   * This method will be called once during SDK initialization before the register method is called.
+   *
+   * If the plugin does not need to register any hooks, this method doesn't need to be implemented.
+   * @param metadata
+   */
+  getHooks?(metadata: LDPluginEnvironmentMetadata): Hook[];
+}
+
   /**
    * LaunchDarkly initialization options that are supported by all variants of the JS client.
    * The browser SDK and Electron SDK may support additional options.
@@ -474,6 +621,13 @@ declare module 'launchdarkly-js-sdk-common' {
      * ```
      */
     hooks?: Hook[];
+
+    /**
+     * A list of plugins to be used with the SDK.
+     *
+     * Plugin support is currently experimental and subject to change.
+     */
+    plugins?: LDPlugin[];
   }
 
   /**