fix(openfeature): implement full ProviderEventEmitter contract in the deferred bridge emitter

@openfeature/core's transferListeners always calls oldProvider.events?.removeHandler(...)
on every subsequent OpenFeature.setProvider() call for a domain, regardless of whether the
app registered any handlers itself. The deferred emitter only implemented addHandler/emit,
so replacing the Datadog OpenFeature provider with another provider at runtime threw
"oldProvider.events.removeHandler is not a function", crashing the customer's app.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: rochdev

packages/dd-trace/src/openfeature/server-sdk-bridge.js

@@ -53,6 +53,38 @@ class DeferredOpenFeatureEventEmitter {
   emit (eventType, details) {
     this.#target()?.emit(eventType, details)
   }
+
+  /**
+   * @param {string} eventType
+   * @param {(details?: unknown) => void} handler
+   */
+  removeHandler (eventType, handler) {
+    this.#target()?.removeHandler(eventType, handler)
+  }
+
+  /**
+   * @param {string} [eventType]
+   */
+  removeAllHandlers (eventType) {
+    this.#target()?.removeAllHandlers(eventType)
+  }
+
+  /**
+   * @param {string} eventType
+   * @returns {((details?: unknown) => void)[]}
+   */
+  getHandlers (eventType) {
+    return this.#target()?.getHandlers(eventType) ?? []
+  }
+
+  /**
+   * @param {import('@openfeature/server-sdk').Logger} logger
+   * @returns {this}
+   */
+  setLogger (logger) {
+    this.#target()?.setLogger(logger)
+    return this
+  }
 }
 
 module.exports = {

packages/dd-trace/test/openfeature/server-sdk-bridge.spec.js

@@ -29,6 +29,10 @@ describe('OpenFeature server-sdk bridge', () => {
 
     emitter.addHandler(bridge.ProviderEvents.Ready, sinon.spy())
     emitter.emit(bridge.ProviderEvents.Ready)
+    emitter.removeHandler(bridge.ProviderEvents.Ready, sinon.spy())
+    emitter.removeAllHandlers(bridge.ProviderEvents.Ready)
+    assert.deepStrictEqual(emitter.getHandlers(bridge.ProviderEvents.Ready), [])
+    assert.strictEqual(emitter.setLogger({}), emitter)
   })
 
   it('forwards addHandler and emit to the real emitter once one is registered', () => {
@@ -52,6 +56,37 @@ describe('OpenFeature server-sdk bridge', () => {
     sinon.assert.calledOnceWithExactly(handler, { some: 'details' })
   })
 
+  it('forwards removeHandler, removeAllHandlers, getHandlers, and setLogger to the real emitter', () => {
+    const handlers = [sinon.spy()]
+    const realEmitterInstance = {
+      addHandler: sinon.spy(),
+      emit: sinon.spy(),
+      removeHandler: sinon.spy(),
+      removeAllHandlers: sinon.spy(),
+      getHandlers: sinon.stub().returns(handlers),
+      setLogger: sinon.spy(),
+    }
+    const RealEventEmitter = sinon.stub().returns(realEmitterInstance)
+
+    bridge.setEventEmitter(RealEventEmitter)
+
+    const emitter = new bridge.OpenFeatureEventEmitter()
+    const handler = sinon.spy()
+    const logger = {}
+
+    emitter.removeHandler('PROVIDER_READY', handler)
+    emitter.removeAllHandlers('PROVIDER_READY')
+    const result = emitter.getHandlers('PROVIDER_READY')
+    const returned = emitter.setLogger(logger)
+
+    sinon.assert.calledOnceWithExactly(realEmitterInstance.removeHandler, 'PROVIDER_READY', handler)
+    sinon.assert.calledOnceWithExactly(realEmitterInstance.removeAllHandlers, 'PROVIDER_READY')
+    sinon.assert.calledOnceWithExactly(realEmitterInstance.getHandlers, 'PROVIDER_READY')
+    assert.strictEqual(result, handlers)
+    sinon.assert.calledOnceWithExactly(realEmitterInstance.setLogger, logger)
+    assert.strictEqual(returned, emitter)
+  })
+
   it('reuses the same real emitter instance across calls on the same deferred emitter', () => {
     const realEmitterInstance = {
       addHandler: sinon.spy(),