@aws-blocks/core 0.1.4 → 0.1.10

package/src/telemetry/telemetry-send-worker.ts

@@ -0,0 +1,60 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Telemetry send worker — spawned as a detached subprocess.
+ * Reads JSON payload from stdin, POSTs it to the endpoint (argv[2]).
+ *
+ * Uses only Node built-ins — no project imports — so the compiled .js
+ * runs with bare `node` (no tsx needed).
+ */
+
+import { request as httpsRequest } from 'node:https';
+import { request as httpRequest } from 'node:http';
+
+const TIMEOUT_MS = 500;
+const debug = (process.env.NODE_DEBUG || '').includes('blocks-telemetry');
+
+const endpoint = process.argv[2];
+if (!endpoint) process.exit(1);
+
+let payload = '';
+process.stdin.setEncoding('utf-8');
+process.stdin.on('data', (chunk: string) => { payload += chunk; });
+process.stdin.on('end', () => {
+  try {
+    const url = new URL(endpoint);
+    const isHttps = url.protocol === 'https:';
+    const requestFn = isHttps ? httpsRequest : httpRequest;
+
+    const req = requestFn({
+      hostname: url.hostname,
+      port: url.port || (isHttps ? '443' : '80'),
+      path: url.pathname + url.search,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(payload),
+      },
+      timeout: TIMEOUT_MS,
+    }, (res) => {
+      res.resume();
+      if (debug) process.stderr.write(`BLOCKS-TELEMETRY: sent (status=${res.statusCode})\n`);
+      process.exit(0);
+    });
+
+    req.on('error', (e) => {
+      if (debug) process.stderr.write(`BLOCKS-TELEMETRY: error: ${(e as Error).message}\n`);
+      process.exit(1);
+    });
+    req.on('timeout', () => {
+      if (debug) process.stderr.write(`BLOCKS-TELEMETRY: timed out\n`);
+      req.destroy();
+      process.exit(1);
+    });
+    req.write(payload);
+    req.end();
+  } catch {
+    process.exit(1);
+  }
+});

package/src/telemetry/telemetry.test.ts

@@ -11,7 +11,7 @@ import { isCI, detectOS, detectNodeVersion, detectPackageManager, detectAgent, c
 import { trackCommand, classifyError } from './trackCommand.js';
 import { buildAndSendEvent, buildEvent, sendEvent, getTelemetryFilePath } from './client.js';
 import { getInstallationId, getProjectId, generateEventId } from './identifiers.js';
-import { spawnSync } from 'node:child_process';
+import { spawnSync, spawn as spawnChild } from 'node:child_process';
 import type { BlocksTelemetryEvent } from './types.js';
 import { Scope, OFFICIAL_BB_NAMES } from '../common/index.js';
 import type { ScopeParent } from '../common/index.js';
@@ -533,6 +533,96 @@ describe('telemetry/client', () => {
   });
 });
 
+describe('telemetry/send-worker', () => {
+  it('worker POSTs payload from stdin to endpoint', async () => {
+    const received: string[] = [];
+
+    const server: Server = await new Promise((resolve) => {
+      const s = createServer((req, res) => {
+        let body = '';
+        req.on('data', (chunk) => { body += chunk; });
+        req.on('end', () => {
+          received.push(body);
+          res.writeHead(200);
+          res.end();
+        });
+      });
+      s.listen(0, '127.0.0.1', () => resolve(s));
+    });
+
+    const addr = server.address() as { port: number };
+    const endpoint = `http://127.0.0.1:${addr.port}/collect`;
+    const payload = JSON.stringify({ test: true, command: 'dev' });
+    const workerPath = join(__dirname, 'telemetry-send-worker.js');
+
+    const exitCode = await new Promise<number | null>((resolve) => {
+      const proc = spawnChild(process.execPath, [workerPath, endpoint], {
+        stdio: ['pipe', 'ignore', 'ignore'],
+        env: { ...process.env, NODE_OPTIONS: '' },
+      });
+      proc.stdin!.write(payload);
+      proc.stdin!.end();
+      proc.on('close', (code) => resolve(code));
+    });
+
+    assert.strictEqual(exitCode, 0);
+    assert.strictEqual(received.length, 1);
+    assert.deepStrictEqual(JSON.parse(received[0]), { test: true, command: 'dev' });
+
+    server.close();
+  });
+
+  it('worker exits with 1 on unreachable endpoint', async () => {
+    const payload = JSON.stringify({ test: true });
+    const workerPath = join(__dirname, 'telemetry-send-worker.js');
+
+    const exitCode = await new Promise<number | null>((resolve) => {
+      const proc = spawnChild(process.execPath, [workerPath, 'http://127.0.0.1:1/unreachable'], {
+        stdio: ['pipe', 'ignore', 'ignore'],
+        env: { ...process.env, NODE_OPTIONS: '' },
+      });
+      proc.stdin!.write(payload);
+      proc.stdin!.end();
+      proc.on('close', (code) => resolve(code));
+    });
+
+    assert.strictEqual(exitCode, 1);
+  });
+
+  it('worker writes debug output to stderr when NODE_DEBUG is set', async () => {
+    const server: Server = await new Promise((resolve) => {
+      const s = createServer((req, res) => {
+        let body = '';
+        req.on('data', (chunk) => { body += chunk; });
+        req.on('end', () => { res.writeHead(200); res.end(); });
+      });
+      s.listen(0, '127.0.0.1', () => resolve(s));
+    });
+
+    const addr = server.address() as { port: number };
+    const endpoint = `http://127.0.0.1:${addr.port}/collect`;
+    const payload = JSON.stringify({ test: true });
+    const workerPath = join(__dirname, 'telemetry-send-worker.js');
+
+    const result = await new Promise<{ code: number | null; stderr: string }>((resolve) => {
+      const proc = spawnChild(process.execPath, [workerPath, endpoint], {
+        stdio: ['pipe', 'ignore', 'pipe'],
+        env: { ...process.env, NODE_OPTIONS: '', NODE_DEBUG: 'blocks-telemetry' },
+      });
+      let stderr = '';
+      proc.stderr!.on('data', (chunk: Buffer) => { stderr += chunk.toString(); });
+      proc.stdin!.write(payload);
+      proc.stdin!.end();
+      proc.on('close', (code) => resolve({ code, stderr }));
+    });
+
+    assert.strictEqual(result.code, 0);
+    assert.ok(result.stderr.includes('BLOCKS-TELEMETRY: sent (status=200)'), `Expected debug output, got: ${result.stderr}`);
+
+    server.close();
+  });
+});
+
 describe('telemetry/trackCommand integration', () => {
   const originalEnv = { ...process.env };
 

package/src/telemetry/trackCommand.ts

@@ -22,10 +22,10 @@ export function classifyError(error: unknown): { code: string; phase: string } {
   if (msg.includes('cdk synth') || msg.includes('synthesis')) {
     return { code: 'CDK_SYNTH_FAILED', phase: 'synth' };
   }
-  if (msg.includes('cdk deploy') || msg.includes('deployment failed')) {
+  if (msg.includes('cdk deploy') || msg.includes('deployment failed') || (msg.includes('cdk') && msg.includes('deploy') && msg.includes('exited with code'))) {
     return { code: 'CDK_DEPLOY_FAILED', phase: 'deploy' };
   }
-  if (msg.includes('cdk destroy') || msg.includes('destroy failed')) {
+  if (msg.includes('cdk destroy') || msg.includes('destroy failed') || (msg.includes('cdk') && msg.includes('destroy') && msg.includes('exited with code'))) {
     return { code: 'CDK_DESTROY_FAILED', phase: 'destroy' };
   }
   if (msg.includes('npm install') || msg.includes('npm err')) {
@@ -52,7 +52,7 @@ export function classifyError(error: unknown): { code: string; phase: string } {
  *
  * Measures wall-clock duration, classifies errors, and sends a single telemetry event
  * after the command completes (success or failure). The telemetry send is fire-and-forget
- * and bounded by a 5s timeout — it will never delay the command or affect its exit code.
+ * and bounded by a 500ms timeout — it will never delay the command or affect its exit code.
  *
  * If telemetry is disabled (via env var or config), the function is executed directly
  * with zero overhead.

package/src/version.ts

@@ -1,2 +1,2 @@
 // Auto-generated by scripts/generate-version.mjs — do not edit manually
-export const CORE_VERSION = '0.1.4';
+export const CORE_VERSION = '0.1.10';