JS-1453 Address PR feedback and add telemetry normalization tests

Author: zglicz

packages/jsts/src/analysis/projectAnalysis/analyzeWithProgram.ts

@@ -177,10 +177,7 @@ async function analyzeFilesFromEntryPoint(
   programOptions.host = new IncrementalCompilerHost(programOptions.options, baseDir);
 
   telemetry.recordProgramCreationAttempt();
-  const tsProgram = createStandardProgram(programOptions, {
-    onProgramCreated: () => telemetry.recordProgramCreationSuccess(),
-    onProgramCreationError: () => telemetry.recordProgramCreationFailure(),
-  });
+  const tsProgram = createStandardProgram(programOptions);
   const detectedEsYear = esLibToYear(programOptions.options.lib);
   telemetry.recordEcmaScriptVersion(detectedEsYear ?? undefined);
 
@@ -251,10 +248,7 @@ async function analyzeFilesFromTsConfig(
     `Creating TypeScript(${ts.version}) program with configuration file ${tsconfig} [lib: ${programOptions.options.lib?.join(', ')}]`,
   );
   programOptions.host = new IncrementalCompilerHost(programOptions.options, baseDir);
-  const tsProgram = createStandardProgram(programOptions, {
-    onProgramCreated: () => telemetry.recordProgramCreationSuccess(),
-    onProgramCreationError: () => telemetry.recordProgramCreationFailure(),
-  });
+  const tsProgram = createStandardProgram(programOptions);
   const detectedEsYear = esLibToYear(programOptions.options.lib);
   telemetry.recordEcmaScriptVersion(detectedEsYear ?? undefined);
 

packages/jsts/src/analysis/projectAnalysis/telemetry.ts

@@ -53,6 +53,10 @@ export function getProjectAnalysisTelemetryCollector() {
   return projectAnalysisTelemetryCollector;
 }
 
+export function getOptionalProjectAnalysisTelemetryCollector() {
+  return projectAnalysisTelemetryCollector;
+}
+
 export function getProjectAnalysisTelemetry(): ProjectAnalysisTelemetry {
   return getProjectAnalysisTelemetryCollector().getTelemetry();
 }
@@ -108,7 +112,7 @@ export class ProjectAnalysisTelemetryCollector {
   getTelemetry(): ProjectAnalysisTelemetry {
     const compilerOptions: Record<string, string[]> = {};
     for (const [optionName, values] of this.compilerOptionValues.entries()) {
-      const sorted = Array.from(values).sort();
+      const sorted = Array.from(values).sort((a, b) => a.localeCompare(b));
       if (sorted.length > 0) {
         compilerOptions[optionName] = sorted;
       }
@@ -120,7 +124,7 @@ export class ProjectAnalysisTelemetryCollector {
       compilerOptions,
       ecmaScriptVersions:
         this.ecmaScriptVersions.size > 0
-          ? Array.from(this.ecmaScriptVersions).sort()
+          ? Array.from(this.ecmaScriptVersions).sort((a, b) => a.localeCompare(b))
           : [NOT_DETECTED],
       programCreation: this.programCreation,
     };
@@ -134,10 +138,11 @@ export class ProjectAnalysisTelemetryCollector {
     if (values.length === 0) {
       return;
     }
-    if (!this.compilerOptionValues.has(optionName)) {
-      this.compilerOptionValues.set(optionName, new Set());
+    let target = this.compilerOptionValues.get(optionName);
+    if (!target) {
+      target = new Set<string>();
+      this.compilerOptionValues.set(optionName, target);
     }
-    const target = this.compilerOptionValues.get(optionName)!;
     for (const value of values) {
       target.add(value);
     }
@@ -172,17 +177,18 @@ export class ProjectAnalysisTelemetryCollector {
       return [JSON.stringify(optionValue)];
     }
 
-    return [String(optionValue)];
+    const json = JSON.stringify(optionValue);
+    return json === undefined ? [] : [json];
   }
 }
 
 function normalizeTypeScriptVersions(typeScriptSignals: string[]): string[] {
   const normalizedVersions = new Set<string>();
   for (const signal of typeScriptSignals) {
     try {
-      const version = minVersion(signal)?.version;
-      if (version) {
-        normalizedVersions.add(version);
+      const resolvedVersion = minVersion(signal)?.version;
+      if (resolvedVersion) {
+        normalizedVersions.add(resolvedVersion);
       }
     } catch {
       continue;
@@ -191,21 +197,27 @@ function normalizeTypeScriptVersions(typeScriptSignals: string[]): string[] {
   if (normalizedVersions.size === 0) {
     return [NOT_DETECTED];
   }
-  return Array.from(normalizedVersions).sort();
+  return Array.from(normalizedVersions).sort((a, b) => a.localeCompare(b));
 }
 
 function getAvailablePackageJsons(): PackageJson[] {
   const packageJsons: PackageJson[] = [];
+  let packageJsonFiles: Iterable<{ content: string | Buffer }>;
   try {
-    for (const packageJsonFile of packageJsonStore.getPackageJsons().values()) {
-      const content =
-        typeof packageJsonFile.content === 'string'
-          ? packageJsonFile.content
-          : packageJsonFile.content.toString();
+    packageJsonFiles = packageJsonStore.getPackageJsons().values();
+  } catch {
+    return packageJsons;
+  }
+  for (const packageJsonFile of packageJsonFiles) {
+    const content =
+      typeof packageJsonFile.content === 'string'
+        ? packageJsonFile.content
+        : packageJsonFile.content.toString();
+    try {
       packageJsons.push(JSON.parse(stripBOM(content)) as PackageJson);
+    } catch {
+      continue;
     }
-  } catch {
-    return [];
   }
   return packageJsons;
 }

packages/jsts/src/program/factory.ts

@@ -25,11 +25,7 @@ import { info } from '../../../shared/src/helpers/logging.js';
 import { getProgramCacheManager } from './cache/programCache.js';
 import { getCurrentFilesContext } from './cache/sourceFileCache.js';
 import { normalizeToAbsolutePath, type NormalizedAbsolutePath } from '../rules/helpers/files.js';
-
-type ProgramCreationCallbacks = {
-  onProgramCreated?: () => void;
-  onProgramCreationError?: () => void;
-};
+import { getOptionalProjectAnalysisTelemetryCollector } from '../analysis/projectAnalysis/telemetry.js';
 
 function createBuilderProgramWithHost(
   programOptions: ProgramOptions,
@@ -90,19 +86,16 @@ function createBuilderProgramAndHost(
  * enforces this at compile time.
  *
  * @param programOptions - Program options from createProgramOptions()
- * @param callbacks - Optional hooks triggered on creation success or failure
  * @returns Standard TypeScript Program
  */
-export function createStandardProgram(
-  programOptions: ProgramOptions,
-  callbacks: ProgramCreationCallbacks = {},
-): ts.Program {
+export function createStandardProgram(programOptions: ProgramOptions): ts.Program {
+  const telemetryCollector = getOptionalProjectAnalysisTelemetryCollector();
   try {
     const program = ts.createProgram(programOptions);
-    callbacks.onProgramCreated?.();
+    telemetryCollector?.recordProgramCreationSuccess();
     return program;
   } catch (error) {
-    callbacks.onProgramCreationError?.();
+    telemetryCollector?.recordProgramCreationFailure();
     throw error;
   }
 }

packages/jsts/tests/analysis/telemetry.test.ts

@@ -0,0 +1,59 @@
+/*
+ * SonarQube JavaScript Plugin
+ * Copyright (C) 2011-2025 SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+import { beforeEach, describe, it } from 'node:test';
+import { expect } from 'expect';
+import ts from 'typescript';
+import { ProjectAnalysisTelemetryCollector } from '../../src/analysis/projectAnalysis/telemetry.js';
+import { packageJsonStore } from '../../src/analysis/projectAnalysis/file-stores/index.js';
+
+describe('project analysis telemetry', () => {
+  beforeEach(() => {
+    packageJsonStore.clearCache();
+  });
+
+  it('should normalize and merge compiler options across programs', () => {
+    const collector = new ProjectAnalysisTelemetryCollector();
+    collector.recordCompilerOptions({
+      lib: ['lib.es2022.d.ts', 'dom'],
+      module: ts.ModuleKind.CommonJS,
+      strict: true,
+      paths: { '@/*': ['src/*'] },
+    });
+    collector.recordCompilerOptions({
+      lib: ['lib.es2020.d.ts', 'dom'],
+      module: ts.ModuleKind.NodeNext,
+      strict: true,
+    });
+
+    expect(collector.getTelemetry().compilerOptions).toEqual({
+      lib: ['dom', 'es2020', 'es2022'],
+      module: ['commonjs', 'nodenext'],
+      paths: ['{"@/*":["src/*"]}'],
+      strict: ['true'],
+    });
+  });
+
+  it('should ignore compiler option values that cannot be JSON stringified', () => {
+    const collector = new ProjectAnalysisTelemetryCollector();
+    collector.recordCompilerOptions({
+      customOption: Symbol('custom'),
+    } as unknown as ts.CompilerOptions);
+    collector.recordCompilerOptions({ customOption: undefined } as unknown as ts.CompilerOptions);
+
+    expect(collector.getTelemetry().compilerOptions.customOption).toBeUndefined();
+  });
+});

sonar-plugin/sonar-javascript-plugin/src/main/java/org/sonar/plugins/javascript/analysis/PluginTelemetry.java

@@ -142,7 +142,7 @@ private static void addCompilerOptionTelemetry(
     String option,
     @Nullable List<String> values
   ) {
-    if (option == null || option.isBlank()) {
+    if (option.isBlank()) {
       return;
     }
     addValueList(keyMapToSave, TELEMETRY_PREFIX + "typescript.compiler-options." + option, values);