Merge pull request #472 from forcedotcom/W-21215399-fix-telemetry-with-schema

fix: @W-21215399 - send only caller attributes in sendTelemetryEventWithSchema

Author: smuduganti-sf

README.md

@@ -107,8 +107,8 @@ const reporter = await TelemetryReporter.create({
 reporter.start();
 // Default events use the default schema
 reporter.sendTelemetryEvent('event-name', { foo: 'bar' });
-// PFT or other schema-specific events: pass schema per call
-reporter.sendTelemetryEventWithSchema('pftEventName', { userId: 'user-1', action: 'view' }, pdpEventSchema);
+// Schema-specific events: pass only attributes (must include all fields required by the schema; no properties added by reporter)
+reporter.sendTelemetryEventWithSchema({ userId: 'user-1', action: 'view', eventName: 'pftEventName' }, pdpEventSchema);
 ```
 
 **Note:** `sendTelemetryEventWithSchema` sends only to O11y (not AppInsights). Use it for events that must conform to a given schema; use `sendTelemetryEvent` for all other events.

src/o11yReporter.ts

@@ -101,24 +101,20 @@ export class O11yReporter extends BaseReporter {
    * Use this method when you need to send events that conform to a particular schema
    * (e.g. PFT/pdpEventSchema). Only the events you send via this method use the given schema;
    * all other events use the default schema via sendTelemetryEvent.
+   * Only the caller-provided attributes are sent; no properties (e.g. eventName, common.*)
+   * are added by the reporter.
    *
-   * @param eventName - Name of the event
-   * @param attributes - Properties and measurements to publish alongside the event
-   * @param schema - O11y schema object (e.g. from o11y_schema package)
+   * The schema is the O11y encoding schema (e.g. from the o11y_schema package), not JSON Schema,
+   * so this library does not derive or run validation here. Callers should validate attributes
+   * (e.g. with zod) before calling, using the same schema context they use when importing the schema.
+   *
+   * @param attributes - Properties and measurements to publish (only these are sent; no properties added)
+   * @param schema - O11y encoding schema (e.g. from o11y_schema package)
    */
-  public async sendTelemetryEventWithSchema(
-    eventName: string,
-    attributes: Attributes,
-    schema: O11ySchema
-  ): Promise<void> {
+  public async sendTelemetryEventWithSchema(attributes: Attributes, schema: O11ySchema): Promise<void> {
     await this.initialized;
 
-    const merged = { ...this.commonProperties, ...attributes };
-
-    const eventData: { [key: string]: unknown } = {
-      eventName: `${this.extensionName}/${eventName}`,
-      ...merged,
-    };
+    const eventData: { [key: string]: unknown } = { ...attributes };
 
     this.service.logEventWithSchema(eventData, schema);
 

src/telemetryReporter.ts

@@ -163,14 +163,18 @@ export class TelemetryReporter extends AsyncCreatable<TelemetryOptions> {
    * Sends a telemetry event to O11y only with a specific schema.
    * Use this for events that must conform to a given schema (e.g. PFT/pdpEventSchema).
    * Does not send to AppInsights. Only sends when O11y is enabled and reporter is initialized.
+   * Only the caller-provided attributes are sent; no properties are added by the reporter.
    *
-   * @param eventName - Name of the event
-   * @param attributes - Properties and measurements to publish alongside the event
-   * @param schema - O11y schema object (e.g. from o11y_schema package)
+   * The schema is the O11y encoding schema (e.g. from the o11y_schema package), not JSON Schema,
+   * so this library does not derive or run validation here. Callers should validate attributes
+   * (e.g. with zod) before calling, using the same schema context they use when importing the schema.
+   *
+   * @param attributes - Properties and measurements to publish (only these are sent)
+   * @param schema - O11y encoding schema (e.g. from o11y_schema package)
    */
-  public sendTelemetryEventWithSchema(eventName: string, attributes: Attributes, schema: O11ySchema): void {
+  public sendTelemetryEventWithSchema(attributes: Attributes, schema: O11ySchema): void {
     if (this.isSfdxTelemetryEnabled() && this.enableO11y && this.o11yReporter) {
-      void this.o11yReporter.sendTelemetryEventWithSchema(eventName, attributes, schema).catch((error) => {
+      void this.o11yReporter.sendTelemetryEventWithSchema(attributes, schema).catch((error) => {
         this.logger.debug('Failed to send event with schema to O11y:', error);
       });
     }

test/unit/o11yReporter.test.ts

@@ -113,31 +113,31 @@ describe('O11yReporter', () => {
       reporter = new O11yReporter({ project, key, extensionName, o11yUploadEndpoint });
     });
 
-    it('should call logEventWithSchema with given schema and event data', async () => {
+    it('should call logEventWithSchema with given schema and caller attributes only', async () => {
       const schema = { name: 'pdpEventSchema', version: '1.0' };
-      const eventName = 'pftEvent';
       const attributes = { userId: 'user-1', action: 'view' };
 
-      await reporter.sendTelemetryEventWithSchema(eventName, attributes, schema);
+      await reporter.sendTelemetryEventWithSchema(attributes, schema);
 
       expect(mockO11yService.logEventWithSchema.called).to.be.true;
       expect(mockO11yService.logEvent.called).to.be.false;
       expect(mockO11yService.forceFlush.called).to.be.true;
 
       const callArgs = mockO11yService.logEventWithSchema.firstCall.args;
-      expect(callArgs[0].eventName).to.equal(`${extensionName}/${eventName}`);
+      expect(callArgs[0]).to.deep.equal(attributes);
       expect(callArgs[0].userId).to.equal('user-1');
       expect(callArgs[0].action).to.equal('view');
       expect(callArgs[1]).to.equal(schema);
     });
 
-    it('should merge common properties with attributes', async () => {
+    it('should include only caller-provided attributes (no eventName or common properties)', async () => {
       const schema = { name: 'custom-schema', version: '1.0' };
-      await reporter.sendTelemetryEventWithSchema('myEvent', { foo: 'bar' }, schema);
+      await reporter.sendTelemetryEventWithSchema({ foo: 'bar' }, schema);
 
       const eventData = mockO11yService.logEventWithSchema.firstCall.args[0];
-      expect(eventData['common.extensionName']).to.equal(extensionName);
       expect(eventData.foo).to.equal('bar');
+      expect(eventData.eventName).to.be.undefined;
+      expect(eventData['common.extensionName']).to.be.undefined;
     });
   });