Merge pull request #32072 from storybookjs/valentin/add-node-linker-to-telemetry

Telemetry: Add nodeLinker to telemetry

Author: valentinpalkovic

code/core/src/telemetry/get-package-manager-info.test.ts

@@ -0,0 +1,221 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+// eslint-disable-next-line depend/ban-dependencies
+import { execaCommand as rawExecaCommand } from 'execa';
+import { detect as rawDetect } from 'package-manager-detector';
+
+import { getPackageManagerInfo } from './get-package-manager-info';
+
+vi.mock('execa', async () => {
+  return {
+    execaCommand: vi.fn(),
+  };
+});
+
+vi.mock('package-manager-detector', async () => {
+  return {
+    detect: vi.fn(),
+  };
+});
+
+vi.mock('../common', async () => {
+  return {
+    getProjectRoot: () => '/mock/project/root',
+  };
+});
+
+const execaCommand = vi.mocked(rawExecaCommand);
+const detect = vi.mocked(rawDetect);
+
+beforeEach(() => {
+  execaCommand.mockReset();
+  detect.mockReset();
+});
+
+describe('getPackageManagerInfo', () => {
+  describe('when no package manager is detected', () => {
+    it('should return undefined', async () => {
+      detect.mockResolvedValue(null);
+
+      const result = await getPackageManagerInfo();
+
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('when yarn is detected', () => {
+    beforeEach(() => {
+      detect.mockResolvedValue({
+        name: 'yarn',
+        version: '3.6.0',
+        agent: 'yarn@berry',
+      });
+    });
+
+    it('should return yarn info with default nodeLinker when command fails', async () => {
+      execaCommand.mockRejectedValue(new Error('Command failed'));
+
+      const result = await getPackageManagerInfo();
+
+      expect(result).toEqual({
+        type: 'yarn',
+        version: '3.6.0',
+        agent: 'yarn@berry',
+        nodeLinker: 'node_modules',
+      });
+    });
+
+    it('should return yarn info with node_modules nodeLinker', async () => {
+      execaCommand.mockResolvedValue({
+        stdout: 'node_modules\n',
+      } as any);
+
+      const result = await getPackageManagerInfo();
+
+      expect(result).toEqual({
+        type: 'yarn',
+        version: '3.6.0',
+        agent: 'yarn@berry',
+        nodeLinker: 'node_modules',
+      });
+    });
+
+    it('should return yarn info with pnp nodeLinker', async () => {
+      execaCommand.mockResolvedValue({
+        stdout: 'pnp\n',
+      } as any);
+
+      const result = await getPackageManagerInfo();
+
+      expect(result).toEqual({
+        type: 'yarn',
+        version: '3.6.0',
+        agent: 'yarn@berry',
+        nodeLinker: 'pnp',
+      });
+    });
+  });
+
+  describe('when pnpm is detected', () => {
+    beforeEach(() => {
+      detect.mockResolvedValue({
+        name: 'pnpm',
+        version: '8.15.0',
+        agent: 'pnpm',
+      });
+    });
+
+    it('should return pnpm info with default isolated nodeLinker when command fails', async () => {
+      execaCommand.mockRejectedValue(new Error('Command failed'));
+
+      const result = await getPackageManagerInfo();
+
+      expect(result).toEqual({
+        type: 'pnpm',
+        version: '8.15.0',
+        agent: 'pnpm',
+        nodeLinker: 'node_modules',
+      });
+    });
+
+    it('should return pnpm info with isolated nodeLinker', async () => {
+      execaCommand.mockResolvedValue({
+        stdout: 'isolated\n',
+      } as any);
+
+      const result = await getPackageManagerInfo();
+
+      expect(result).toEqual({
+        type: 'pnpm',
+        version: '8.15.0',
+        agent: 'pnpm',
+        nodeLinker: 'isolated',
+      });
+    });
+  });
+
+  describe('when npm is detected', () => {
+    beforeEach(() => {
+      detect.mockResolvedValue({
+        name: 'npm',
+        version: '9.8.0',
+        agent: 'npm',
+      });
+    });
+
+    it('should return npm info with default node_modules nodeLinker', async () => {
+      const result = await getPackageManagerInfo();
+
+      expect(result).toEqual({
+        type: 'npm',
+        version: '9.8.0',
+        agent: 'npm',
+        nodeLinker: 'node_modules',
+      });
+      expect(execaCommand).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('when bun is detected', () => {
+    beforeEach(() => {
+      detect.mockResolvedValue({
+        name: 'bun',
+        version: '1.0.0',
+        agent: 'bun',
+      });
+    });
+
+    it('should return bun info with default node_modules nodeLinker', async () => {
+      const result = await getPackageManagerInfo();
+
+      expect(result).toEqual({
+        type: 'bun',
+        version: '1.0.0',
+        agent: 'bun',
+        nodeLinker: 'node_modules',
+      });
+      expect(execaCommand).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('error handling', () => {
+    beforeEach(() => {
+      detect.mockResolvedValue({
+        name: 'yarn',
+        version: '3.6.0',
+        agent: 'yarn',
+      });
+    });
+
+    it('should handle yarn command errors gracefully', async () => {
+      execaCommand.mockRejectedValue(new Error('yarn command not found'));
+
+      const result = await getPackageManagerInfo();
+
+      expect(result).toEqual({
+        type: 'yarn',
+        version: '3.6.0',
+        agent: 'yarn',
+        nodeLinker: 'node_modules',
+      });
+    });
+
+    it('should handle pnpm command errors gracefully', async () => {
+      detect.mockResolvedValue({
+        name: 'pnpm',
+        version: '8.15.0',
+        agent: 'pnpm',
+      });
+      execaCommand.mockRejectedValue(new Error('pnpm command not found'));
+
+      const result = await getPackageManagerInfo();
+
+      expect(result).toEqual({
+        type: 'pnpm',
+        version: '8.15.0',
+        agent: 'pnpm',
+        nodeLinker: 'node_modules',
+      });
+    });
+  });
+});

code/core/src/telemetry/get-package-manager-info.ts

@@ -0,0 +1,40 @@
+// eslint-disable-next-line depend/ban-dependencies
+import { execaCommand } from 'execa';
+import { detect } from 'package-manager-detector';
+
+import { getProjectRoot } from '../common';
+
+export const getPackageManagerInfo = async () => {
+  const packageManagerType = await detect({ cwd: getProjectRoot() });
+
+  if (!packageManagerType) {
+    return undefined;
+  }
+
+  let nodeLinker: 'node_modules' | 'pnp' | 'pnpm' | 'isolated' | 'hoisted' = 'node_modules';
+
+  if (packageManagerType.name === 'yarn') {
+    try {
+      const { stdout } = await execaCommand('yarn config get nodeLinker', {
+        cwd: getProjectRoot(),
+      });
+      nodeLinker = stdout.trim() as 'node_modules' | 'pnp' | 'pnpm';
+    } catch (e) {}
+  }
+
+  if (packageManagerType.name === 'pnpm') {
+    try {
+      const { stdout } = await execaCommand('pnpm config get nodeLinker', {
+        cwd: getProjectRoot(),
+      });
+      nodeLinker = (stdout.trim() as 'isolated' | 'hoisted' | 'pnpm') ?? 'isolated';
+    } catch (e) {}
+  }
+
+  return {
+    type: packageManagerType.name,
+    version: packageManagerType.version,
+    agent: packageManagerType.agent,
+    nodeLinker,
+  };
+};

code/core/src/telemetry/storybook-metadata.ts

@@ -1,7 +1,6 @@
 import { dirname } from 'node:path';
 
 import {
-  getProjectRoot,
   getStorybookConfiguration,
   getStorybookInfo,
   loadMainConfig,
@@ -11,7 +10,6 @@ import { readConfig } from 'storybook/internal/csf-tools';
 import type { PackageJson, StorybookConfig } from 'storybook/internal/types';
 
 import { findPackage, findPackagePath } from 'fd-package-json';
-import { detect } from 'package-manager-detector';
 
 import { version } from '../../package.json';
 import { globalSettings } from '../cli/globalSettings';
@@ -20,6 +18,7 @@ import { getChromaticVersionSpecifier } from './get-chromatic-version';
 import { getFrameworkInfo } from './get-framework-info';
 import { getHasRouterPackage } from './get-has-router-package';
 import { getMonorepoType } from './get-monorepo-type';
+import { getPackageManagerInfo } from './get-package-manager-info';
 import { getPortableStoriesFileCount } from './get-portable-stories-usage';
 import { getActualPackageVersion, getActualPackageVersions } from './package-json';
 import { cleanPaths } from './sanitize';
@@ -120,19 +119,7 @@ export const computeStorybookMetadata = async ({
     metadata.monorepo = monorepoType;
   }
 
-  try {
-    const packageManagerType = await detect({ cwd: getProjectRoot() });
-    if (packageManagerType) {
-      metadata.packageManager = {
-        type: packageManagerType.name,
-        version: packageManagerType.version,
-        agent: packageManagerType.agent,
-      };
-    }
-
-    // Better be safe than sorry, some codebases/paths might end up breaking with something like "spawn pnpm ENOENT"
-    // so we just set the package manager if the detection is successful
-  } catch (err) {}
+  metadata.packageManager = await getPackageManagerInfo();
 
   const language = allDependencies.typescript ? 'typescript' : 'javascript';
 

code/core/src/telemetry/types.ts

@@ -58,6 +58,7 @@ export type StorybookMetadata = {
     type: DetectResult['name'];
     version: DetectResult['version'];
     agent: DetectResult['agent'];
+    nodeLinker: 'node_modules' | 'pnp' | 'pnpm' | 'isolated' | 'hoisted';
   };
   typescriptOptions?: Partial<TypescriptOptions>;
   addons?: Record<string, StorybookAddon>;