feat(toolkit-lib): network detector

Author: kaizencc

packages/@aws-cdk/toolkit-lib/lib/api/notices/web-data-source.ts

@@ -4,6 +4,7 @@ import * as https from 'node:https';
 import type { Notice, NoticeDataSource } from './types';
 import { ToolkitError } from '../../toolkit/toolkit-error';
 import { formatErrorMessage, humanHttpStatusError, humanNetworkError } from '../../util';
+import { NetworkDetector } from '../../util/network-detector';
 import type { IoHelper } from '../io/private';
 
 /**
@@ -44,6 +45,12 @@ export class WebsiteNoticeDataSource implements NoticeDataSource {
   }
 
   async fetch(): Promise<Notice[]> {
+    // Check connectivity before attempting network request
+    const hasConnectivity = await NetworkDetector.hasConnectivity(this.agent);
+    if (!hasConnectivity) {
+      throw new ToolkitError('No internet connectivity detected');
+    }
+
     // We are observing lots of timeouts when running in a massively parallel
     // integration test environment, so wait for a longer timeout there.
     //

packages/@aws-cdk/toolkit-lib/lib/util/network-detector.ts

@@ -5,18 +5,12 @@ import { request } from 'https';
  * Detects internet connectivity by making a lightweight request to the notices endpoint
  */
 export class NetworkDetector {
-  private static readonly CACHE_DURATION_MS = 30_000; // 30 seconds
-  private static readonly TIMEOUT_MS = 500;
-  
-  private static cachedResult: boolean | undefined;
-  private static cacheExpiry: number = 0;
-
   /**
    * Check if internet connectivity is available
    */
   public static async hasConnectivity(agent?: Agent): Promise<boolean> {
     const now = Date.now();
-    
+
     // Return cached result if still valid
     if (this.cachedResult !== undefined && now < this.cacheExpiry) {
       return this.cachedResult;
@@ -34,6 +28,12 @@ export class NetworkDetector {
     }
   }
 
+  private static readonly CACHE_DURATION_MS = 30_000; // 30 seconds
+  private static readonly TIMEOUT_MS = 500;
+
+  private static cachedResult: boolean | undefined;
+  private static cacheExpiry: number = 0;
+
   private static ping(agent?: Agent): Promise<boolean> {
     return new Promise((resolve) => {
       const req = request({

packages/@aws-cdk/toolkit-lib/test/api/notices.test.ts

@@ -11,6 +11,7 @@ import { FilteredNotice, NoticesFilter } from '../../lib/api/notices/filter';
 import type { BootstrappedEnvironment, Component, Notice } from '../../lib/api/notices/types';
 import { WebsiteNoticeDataSource } from '../../lib/api/notices/web-data-source';
 import { Settings } from '../../lib/api/settings';
+import { NetworkDetector } from '../../lib/util/network-detector';
 import { TestIoHost } from '../_helpers';
 
 const BASIC_BOOTSTRAP_NOTICE = {
@@ -540,6 +541,24 @@ function parseTestComponent(x: string): Component {
 describe(WebsiteNoticeDataSource, () => {
   const dataSource = new WebsiteNoticeDataSource(ioHelper);
 
+  beforeEach(() => {
+    // Mock NetworkDetector to return true by default for existing tests
+    jest.spyOn(NetworkDetector, 'hasConnectivity').mockResolvedValue(true);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test('throws error when no connectivity detected', async () => {
+    const mockHasConnectivity = jest.spyOn(NetworkDetector, 'hasConnectivity').mockResolvedValue(false);
+
+    await expect(dataSource.fetch()).rejects.toThrow('No internet connectivity detected');
+    expect(mockHasConnectivity).toHaveBeenCalledWith(undefined);
+
+    mockHasConnectivity.mockRestore();
+  });
+
   test('returns data when download succeeds', async () => {
     const result = await mockCall(200, {
       notices: [BASIC_NOTICE, MULTIPLE_AFFECTED_VERSIONS_NOTICE],

packages/@aws-cdk/toolkit-lib/test/util/network-detector.test.ts

@@ -25,7 +25,7 @@ describe('NetworkDetector', () => {
       destroy: jest.fn(),
     };
 
-    mockRequest.mockImplementation((_, callback) => {
+    mockRequest.mockImplementation((_options, callback) => {
       callback({ statusCode: 200 });
       return mockReq;
     });
@@ -41,7 +41,7 @@ describe('NetworkDetector', () => {
       destroy: jest.fn(),
     };
 
-    mockRequest.mockImplementation((_, callback) => {
+    mockRequest.mockImplementation((_options, callback) => {
       callback({ statusCode: 500 });
       return mockReq;
     });
@@ -91,7 +91,7 @@ describe('NetworkDetector', () => {
       destroy: jest.fn(),
     };
 
-    mockRequest.mockImplementation((_, callback) => {
+    mockRequest.mockImplementation((_options, callback) => {
       callback({ statusCode: 200 });
       return mockReq;
     });

packages/aws-cdk/lib/cli/telemetry/sink/endpoint-sink.ts

@@ -2,7 +2,7 @@ import type { IncomingMessage } from 'http';
 import type { Agent } from 'https';
 import { request } from 'https';
 import { parse, type UrlWithStringQuery } from 'url';
-import { ToolkitError } from '@aws-cdk/toolkit-lib';
+import { ToolkitError, NetworkDetector } from '@aws-cdk/toolkit-lib';
 import { IoHelper } from '../../../api-private';
 import type { IIoHost } from '../../io-host';
 import type { TelemetrySchema } from '../schema';
@@ -94,6 +94,13 @@ export class EndpointTelemetrySink implements ITelemetrySink {
     url: UrlWithStringQuery,
     body: { events: TelemetrySchema[] },
   ): Promise<boolean> {
+    // Check connectivity before attempting network request
+    const hasConnectivity = await NetworkDetector.hasConnectivity(this.agent);
+    if (!hasConnectivity) {
+      await this.ioHelper.defaults.trace('No internet connectivity detected, skipping telemetry');
+      return false;
+    }
+
     try {
       const res = await doRequest(url, body, this.agent);
 

packages/aws-cdk/test/cli/telemetry/sink/endpoint-sink.test.ts

@@ -3,18 +3,30 @@ import { createTestEvent } from './util';
 import { IoHelper } from '../../../../lib/api-private';
 import { CliIoHost } from '../../../../lib/cli/io-host';
 import { EndpointTelemetrySink } from '../../../../lib/cli/telemetry/sink/endpoint-sink';
+import { NetworkDetector } from '@aws-cdk/toolkit-lib/lib/util/network-detector';
 
 // Mock the https module
 jest.mock('https', () => ({
   request: jest.fn(),
 }));
 
+// Mock NetworkDetector
+jest.mock('@aws-cdk/toolkit-lib', () => ({
+  ...jest.requireActual('@aws-cdk/toolkit-lib'),
+  NetworkDetector: {
+    hasConnectivity: jest.fn(),
+  },
+}));
+
 describe('EndpointTelemetrySink', () => {
   let ioHost: CliIoHost;
 
   beforeEach(() => {
     jest.resetAllMocks();
 
+    // Mock NetworkDetector to return true by default for existing tests
+    (NetworkDetector.hasConnectivity as jest.Mock).mockResolvedValue(true);
+
     ioHost = CliIoHost.instance();
   });
 
@@ -312,4 +324,20 @@ describe('EndpointTelemetrySink', () => {
       expect.stringContaining('Telemetry Error: POST example.com/telemetry:'),
     );
   });
+
+  test('skips request when no connectivity detected', async () => {
+    // GIVEN
+    (NetworkDetector.hasConnectivity as jest.Mock).mockResolvedValue(false);
+    
+    const testEvent = createTestEvent('INVOKE', { foo: 'bar' });
+    const client = new EndpointTelemetrySink({ endpoint: 'https://example.com/telemetry', ioHost });
+
+    // WHEN
+    await client.emit(testEvent);
+    await client.flush();
+
+    // THEN
+    expect(NetworkDetector.hasConnectivity).toHaveBeenCalledWith(undefined);
+    expect(https.request).not.toHaveBeenCalled();
+  });
 });