Propagate IS_EXTENSION into telemetry (#1574)

Author: tokaplan

appmonitoring/ts/src/.trivyignore

@@ -1,3 +1,7 @@
 #─┬ @kubernetes/[email protected]
 # └── [email protected]
 CVE-2025-59343
+
+#─┬ @kubernetes/[email protected]
+# └── [email protected]
+CVE-2025-64718

appmonitoring/ts/src/LoggerWrapper.ts

@@ -51,13 +51,15 @@ class ClusterMetadata {
     private podName: string;
     private imageTag: string;
     private arch: string;
+    private isExtension: boolean;
 
-    public constructor(clusterArmId: string, clusterArmRegion: string, podName: string, imageTag: string, arch: string) {
+    public constructor(clusterArmId: string, clusterArmRegion: string, podName: string, imageTag: string, arch: string, isExtension: boolean) {
         this.clusterArmId = clusterArmId;
         this.clusterArmRegion = clusterArmRegion;
         this.podName = podName;
         this.imageTag = imageTag;
         this.arch = arch;
+        this.isExtension = isExtension;
     }
 }
 
@@ -105,10 +107,18 @@ class HeartbeatAccumulator {
     public logs : Map<HeartbeatLogs, Map<string, number>> = new Map<HeartbeatLogs, Map<string, number>>();
 }
 
+export function parseIsExtension(value: string | undefined): boolean {
+    if (!value) {
+        return false;
+    }
+    const normalized = value.trim().toLowerCase();
+    return normalized === "true" || normalized === "1" || normalized === "yes";
+}
+
 class LocalLogger {
-    public static Instance(clusterArmId: string, clusterArmRegion: string, podName: string, imageTag: string, arch: string) {
+    public static Instance(clusterArmId: string, clusterArmRegion: string, podName: string, imageTag: string, arch: string, isExtension: boolean) {
         if (!LocalLogger.instance) {
-            LocalLogger.instance = new LocalLogger(clusterArmId, clusterArmRegion, podName, imageTag, arch);
+            LocalLogger.instance = new LocalLogger(clusterArmId, clusterArmRegion, podName, imageTag, arch, isExtension);
         }
 
         return LocalLogger.instance;
@@ -147,10 +157,10 @@ class LocalLogger {
 
     private heartbeatRequestMetadata = new RequestMetadata(null, null);
 
-    private constructor(clusterArmId: string, clusterArmRegion: string, podName: string, imageTag: string, arch: string) {
+    private constructor(clusterArmId: string, clusterArmRegion: string, podName: string, imageTag: string, arch: string, isExtension: boolean) {
         this.client = telemetryClient.telemetryClient;
 
-        this.clusterMetadata = new ClusterMetadata(clusterArmId, clusterArmRegion, podName, imageTag, arch);
+        this.clusterMetadata = new ClusterMetadata(clusterArmId, clusterArmRegion, podName, imageTag, arch, isExtension);
 
         this.log.info(`Application Insights has been set up and started. Default telemetry client is: ${this.client}, cluster metadata: ${JSON.stringify(this.clusterMetadata)}`);
 
@@ -386,4 +396,4 @@ class LocalLogger {
     }
 }
 
-export const logger = LocalLogger.Instance(process.env.ARM_ID, process.env.ARM_REGION, process.env.POD_NAME, process.env.IMAGE_TAG, process.env.ARCH);
+export const logger = LocalLogger.Instance(process.env.ARM_ID, process.env.ARM_REGION, process.env.POD_NAME, process.env.IMAGE_TAG, process.env.ARCH, parseIsExtension(process.env.IS_EXTENSION));

appmonitoring/ts/src/tests/LoggerWrapper.spec.ts

@@ -1,5 +1,5 @@
 import { expect, describe, it } from "@jest/globals";
-import { logger, HeartbeatMetrics, HeartbeatLogs, Watchdogs } from "LoggerWrapper.js";
+import { logger, HeartbeatMetrics, HeartbeatLogs, Watchdogs, parseIsExtension } from "LoggerWrapper.js";
 import * as applicationInsights from "applicationinsights";
 
 beforeEach(() => {
@@ -10,6 +10,99 @@ afterEach(() => {
     jest.restoreAllMocks();
 });
 
+describe("isExtension", () => {
+    describe("Parsing", () => {
+        it("Parses 'true' as true", () => {
+            expect(parseIsExtension("true")).toBe(true);
+        });
+
+        it("Parses '1' as true", () => {
+            expect(parseIsExtension("1")).toBe(true);
+        });
+
+        it("Parses 'yes' as true", () => {
+            expect(parseIsExtension("yes")).toBe(true);
+        });
+
+        it("Parses 'TRUE' (uppercase) as true", () => {
+            expect(parseIsExtension("TRUE")).toBe(true);
+        });
+
+        it("Parses 'false' as false", () => {
+            expect(parseIsExtension("false")).toBe(false);
+        });
+
+        it("Parses '0' as false", () => {
+            expect(parseIsExtension("0")).toBe(false);
+        });
+
+        it("Parses undefined as false", () => {
+            expect(parseIsExtension(undefined)).toBe(false);
+        });
+
+        it("Parses empty string as false", () => {
+            expect(parseIsExtension("")).toBe(false);
+        });
+    });
+
+    describe("Telemetry Inclusion", () => {
+        it("Includes isExtension in event telemetry", async () => {
+            const eventsSent = <applicationInsights.Contracts.EventTelemetry[]>[];
+            
+            jest.spyOn(applicationInsights.TelemetryClient.prototype, "trackEvent").mockImplementation((telemetry: applicationInsights.Contracts.EventTelemetry) => {
+                eventsSent.push(telemetry);
+            });
+
+            await logger.SendEvent("TestEvent", "test-operation-id", "test-uid", false);
+
+            expect(eventsSent.length).toBe(1);
+            expect(eventsSent[0].properties.clusterMetadata).toBeDefined();
+            
+            const clusterMetadata = JSON.parse(eventsSent[0].properties.clusterMetadata);
+            expect(clusterMetadata.isExtension).toBeDefined();
+            expect(typeof clusterMetadata.isExtension).toBe("boolean");
+        });
+
+        it("Includes isExtension in metric telemetry", async () => {
+            logger.setHeartbeatMetric(HeartbeatMetrics.CRCount, 5);
+            
+            const metricsSent = <(applicationInsights.Contracts.MetricTelemetry & applicationInsights.Contracts.MetricPointTelemetry)[]>[];
+            
+            jest.spyOn(applicationInsights.TelemetryClient.prototype, "trackMetric").mockImplementation((telemetry: applicationInsights.Contracts.MetricTelemetry & applicationInsights.Contracts.MetricPointTelemetry) => {
+                metricsSent.push(telemetry);
+            });
+
+            await logger.startHeartbeats("test-operation-id");
+
+            expect(metricsSent.length).toBeGreaterThan(0);
+            expect(metricsSent[0].properties.clusterMetadata).toBeDefined();
+            
+            const clusterMetadata = JSON.parse(metricsSent[0].properties.clusterMetadata);
+            expect(clusterMetadata.isExtension).toBeDefined();
+            expect(typeof clusterMetadata.isExtension).toBe("boolean");
+        });
+
+        it("Includes isExtension in trace telemetry", async () => {
+            logger.appendHeartbeatLog(HeartbeatLogs.ApiServerTopExceptionsEncountered, "test-error");
+            
+            const tracesSent = <applicationInsights.Contracts.TraceTelemetry[]>[];
+            
+            jest.spyOn(applicationInsights.TelemetryClient.prototype, "trackTrace").mockImplementation((telemetry: applicationInsights.Contracts.TraceTelemetry) => {
+                tracesSent.push(telemetry);
+            });
+
+            await logger.startHeartbeats("test-operation-id");
+
+            expect(tracesSent.length).toBeGreaterThan(0);
+            expect(tracesSent[0].properties.clusterMetadata).toBeDefined();
+            
+            const clusterMetadata = JSON.parse(tracesSent[0].properties.clusterMetadata);
+            expect(clusterMetadata.isExtension).toBeDefined();
+            expect(typeof clusterMetadata.isExtension).toBe("boolean");
+        });
+    });
+});
+
 describe("Heartbeats", () => {
     it("Sends logs", async () => {
         for(let i = 0; i < 10; i++) {