node/tools/pgo/pgo-json.js

'use strict';

// PGO Training Script: JSON Processing Workload
//
// JSON.parse() and JSON.stringify() are among the most frequently called
// functions in Node.js applications (every REST API request/response cycle).
// This script exercises the JSON parser and serializer with:
// - Small objects (API responses, config)
// - Medium objects (paginated lists, user profiles)
// - Large objects (analytics payloads, data exports)
// - Nested structures (deep objects, arrays of objects)
// - Various value types (strings, numbers, booleans, null, arrays, objects)
// - Edge cases (unicode, escaped characters, large numbers, empty objects)
// - Realistic patterns: parse → transform → stringify pipeline
//
// This exercises: V8 JSON parser, V8 JSON serializer, string allocation,
// property access patterns, array iteration, GC pressure from allocations.

const DURATION_MS = parseInt(process.env.PGO_TRAINING_DURATION, 10) || 15_000;
const ITERATIONS_PER_BATCH = 500;

// Realistic JSON payloads matching common API shapes

// 1. Small config/health check (~100 bytes)
const SMALL_PAYLOADS = [
  '{"status":"ok","uptime":12345,"version":"1.0.0"}',
  '{"id":42,"name":"test","active":true,"score":98.5}',
  '{"error":null,"data":{"key":"value"},"meta":{}}',
  '{"token":"abc123def456","expires":1700000000}',
  '{"success":true,"count":0,"items":[]}',
];

// 2. Medium user/product objects (~1-5 KB)
function generateUserPayload(count) {
  const users = [];
  for (let i = 0; i < count; i++) {
    users.push({
      id: `usr_${i.toString(36).padStart(8, '0')}`,
      email: `user${i}@company.example.com`,
      name: { first: `First${i}`, last: `Last${i}` },
      role: ['admin', 'editor', 'viewer', 'member'][i % 4],
      permissions: ['read', 'write', 'delete', 'admin'].slice(0, (i % 4) + 1),
      settings: {
        theme: i % 2 === 0 ? 'dark' : 'light',
        language: ['en', 'es', 'fr', 'de', 'ja'][i % 5],
        notifications: { email: true, push: i % 3 !== 0, sms: false },
        timezone: 'America/New_York',
      },
      metadata: {
        createdAt: '2024-01-15T08:30:00.000Z',
        updatedAt: '2024-12-01T14:22:33.456Z',
        lastLogin: '2024-12-15T09:45:00.000Z',
        loginCount: 100 + i * 7,
      },
    });
  }
  return JSON.stringify({ data: users, total: count, page: 1, perPage: count });
}

// 3. Large analytics/event payloads (~50-200 KB)
function generateEventPayload(count) {
  const events = [];
  for (let i = 0; i < count; i++) {
    events.push({
      id: `evt_${Date.now()}_${i}`,
      type: [
        'page_view',
        'click',
        'form_submit',
        'api_call',
        'error',
        'purchase',
      ][i % 6],
      timestamp: new Date(Date.now() - i * 60000).toISOString(),
      session: `sess_${Math.floor(i / 10)}`,
      user: i % 5 === 0 ? null : `usr_${i % 100}`,
      properties: {
        url: `https://example.com/page/${i % 20}?ref=dashboard&utm_source=email`,
        title: `Page Title ${i % 20} — Application Dashboard`,
        referrer: i % 3 === 0 ? 'https://google.com/search?q=test' : '',
        duration: Math.round(Math.random() * 30000),
        viewport: { width: 1920, height: 1080 },
        device: {
          type: ['desktop', 'mobile', 'tablet'][i % 3],
          os: ['Windows 11', 'macOS 14', 'iOS 17', 'Android 14'][i % 4],
          browser: ['Chrome 120', 'Firefox 121', 'Safari 17'][i % 3],
        },
      },
      context: {
        ip: `10.${i % 256}.${(i * 3) % 256}.${(i * 7) % 256}`,
        locale: ['en-US', 'en-GB', 'es-ES', 'fr-FR', 'de-DE'][i % 5],
        campaign:
          i % 10 === 0 ?
            { name: 'holiday_sale', medium: 'email', source: 'mailchimp' } :
            null,
      },
    });
  }
  return JSON.stringify({
    events,
    batch_id: `batch_${Date.now()}`,
    sent_at: new Date().toISOString(),
  });
}

// 4. Deeply nested structure (config files, GraphQL responses)
function generateNestedPayload(depth, breadth) {
  function nest(d) {
    if (d === 0) return { value: 'leaf', count: 42, tags: ['a', 'b'] };
    const obj = {};
    for (let i = 0; i < breadth; i++) {
      obj[`level_${d}_key_${i}`] = nest(d - 1);
    }
    return obj;
  }
  return JSON.stringify({ root: nest(depth), _meta: { depth, breadth } });
}

// 5. Array-heavy payload (table data, CSV-like)
function generateTablePayload(rows, cols) {
  const headers = Array.from({ length: cols }, (_, i) => `column_${i}`);
  const data = [];
  for (let r = 0; r < rows; r++) {
    const row = {};
    for (let c = 0; c < cols; c++) {
      row[headers[c]] =
        c % 3 === 0 ? r * c : c % 3 === 1 ? `val_${r}_${c}` : r % 2 === 0;
    }
    data.push(row);
  }
  return JSON.stringify({ headers, data, rowCount: rows });
}

// 6. Unicode-heavy payload (i18n content)
const UNICODE_PAYLOAD = JSON.stringify({
  messages: {
    en: { greeting: 'Hello, World!', farewell: 'Goodbye!' },
    ja: { greeting: 'こんにちは世界！', farewell: 'さようなら！' },
    ko: { greeting: '안녕하세요 세계!', farewell: '안녕히 가세요!' },
    zh: { greeting: '你好世界！', farewell: '再见！' },
    ar: { greeting: 'مرحبا بالعالم!', farewell: 'مع السلامة!' },
    ru: { greeting: 'Привет мир!', farewell: 'До свидания!' },
    de: { greeting: 'Hallo Welt!', farewell: 'Auf Wiedersehen!' },
    emoji: { greeting: '👋🌍✨', farewell: '👋😢💫' },
  },
  descriptions: Array.from(
    { length: 50 },
    (_, i) =>
      `Item ${i}: Ünîcödé tëst with spëcîal chars — «quotes» "double" 'single' & ampersand \\ backslash / slash`,
  ),
});

// Pre-generate payloads as strings
const mediumPayload10 = generateUserPayload(10);
const mediumPayload50 = generateUserPayload(50);
const largePayload100 = generateEventPayload(100);
const largePayload500 = generateEventPayload(500);
const nestedPayload = generateNestedPayload(5, 3);
const tablePayload = generateTablePayload(200, 15);

// All payloads weighted by real-world frequency
const PAYLOADS = [
  // Small payloads (health checks, simple responses) - most frequent
  ...SMALL_PAYLOADS.map((p) => ({ json: p, weight: 5 })),
  // Medium payloads (typical API responses)
  { json: mediumPayload10, weight: 8 },
  { json: mediumPayload50, weight: 6 },
  // Large payloads (analytics, batch operations)
  { json: largePayload100, weight: 3 },
  { json: largePayload500, weight: 1 },
  // Nested payloads (config, GraphQL)
  { json: nestedPayload, weight: 2 },
  // Table payloads (data grids, reports)
  { json: tablePayload, weight: 2 },
  // Unicode payloads (i18n)
  { json: UNICODE_PAYLOAD, weight: 2 },
];

const weightedPayloads = [];
for (const p of PAYLOADS) {
  for (let i = 0; i < p.weight; i++) {
    weightedPayloads.push(p.json);
  }
}

// Workload 1: Parse → access properties → stringify (REST API middleware pattern)
function workloadParseTransformStringify(jsonStr) {
  const obj = JSON.parse(jsonStr);

  // Typical middleware transforms
  if (obj.data && Array.isArray(obj.data)) {
    // Add computed field (common API pattern)
    for (const item of obj.data) {
      item._computed =
        typeof item.id === 'string' ? item.id.toUpperCase() : String(item.id);
    }
  }
  if (obj.events && Array.isArray(obj.events)) {
    // Filter/transform (analytics pipeline)
    obj.events = obj.events.filter((e) => e.type !== 'error');
    obj.filteredCount = obj.events.length;
  }

  return JSON.stringify(obj);
}

// Workload 2: Parse → extract subset → stringify (GraphQL resolver pattern)
function workloadSelectiveSerialize(jsonStr) {
  const obj = JSON.parse(jsonStr);
  const subset = {};

  // Pick only requested fields (like GraphQL field selection)
  for (const key of Object.keys(obj)) {
    if (typeof obj[key] !== 'object' || obj[key] === null) {
      subset[key] = obj[key];
    } else if (Array.isArray(obj[key]) && obj[key].length > 0) {
      subset[key] = obj[key].slice(0, 5).map((item) => {
        if (typeof item === 'object' && item !== null) {
          const { id, name, type, email } = item;
          return { id, name, type, email };
        }
        return item;
      });
    }
  }

  return JSON.stringify(subset);
}

// Workload 3: Repeated parse/stringify of same shape (template response caching pattern)
function workloadRepeatedShapes() {
  const results = [];
  for (let i = 0; i < 100; i++) {
    const obj = {
      id: i,
      name: `Item ${i}`,
      description: `Description for item ${i} with some additional text`,
      price: (i * 1.5).toFixed(2),
      inStock: i % 3 !== 0,
      categories: ['cat1', 'cat2'],
      ratings: { average: 4.5, count: i * 10 },
    };
    results.push(JSON.stringify(obj));
  }
  // Parse them all back
  return results.map((s) => JSON.parse(s));
}

// Workload 4: JSON.parse with reviver / JSON.stringify with replacer
function workloadReviverReplacer(jsonStr) {
  // Parse with date reviver (common pattern)
  const dateReviver = (key, value) => {
    if (typeof value === 'string' && /^\d{4}-\d{2}-\d{2}T/.test(value)) {
      return new Date(value);
    }
    return value;
  };
  const obj = JSON.parse(jsonStr, dateReviver);

  // Stringify with replacer to exclude nulls (sanitization)
  const nullRemover = (key, value) => (value === null ? undefined : value);
  return JSON.stringify(obj, nullRemover);
}

// Workload 5: Build large JSON incrementally (logging, audit trail)
function workloadIncrementalBuild() {
  const entries = [];
  for (let i = 0; i < 200; i++) {
    entries.push({
      level: ['info', 'warn', 'error', 'debug'][i % 4],
      message: `Log entry ${i}: Operation completed successfully with result code ${i * 3}`,
      timestamp: Date.now() - i * 1000,
      context: { requestId: `req_${i}`, userId: `user_${i % 20}` },
    });
  }
  const logBatch = JSON.stringify({ entries, count: entries.length });
  // Verify round-trip
  const parsed = JSON.parse(logBatch);
  return parsed.count;
}

async function main() {
  console.log('[pgo-json] Starting JSON processing workload...');
  const startTime = Date.now();
  let totalOps = 0;
  let batchNum = 0;

  while (Date.now() - startTime < DURATION_MS) {
    batchNum++;

    // Workload 1: Parse-transform-stringify (highest weight — most common)
    for (let i = 0; i < ITERATIONS_PER_BATCH; i++) {
      const payload = weightedPayloads[i % weightedPayloads.length];
      workloadParseTransformStringify(payload);
      totalOps++;
    }

    // Workload 2: Selective serialization
    for (let i = 0; i < Math.floor(ITERATIONS_PER_BATCH / 2); i++) {
      const payload = weightedPayloads[i % weightedPayloads.length];
      workloadSelectiveSerialize(payload);
      totalOps++;
    }

    // Workload 3: Repeated shapes (every 3rd batch)
    if (batchNum % 3 === 0) {
      workloadRepeatedShapes();
      totalOps += 200; // 100 stringify + 100 parse
    }

    // Workload 4: Reviver/replacer (every 2nd batch)
    if (batchNum % 2 === 0) {
      for (let i = 0; i < 50; i++) {
        const payload = weightedPayloads[i % weightedPayloads.length];
        workloadReviverReplacer(payload);
        totalOps++;
      }
    }

    // Workload 5: Incremental build (every 5th batch)
    if (batchNum % 5 === 0) {
      workloadIncrementalBuild();
      totalOps += 201; // 200 items + 1 round-trip
    }

    // Yield to event loop periodically (realistic for servers)
    if (batchNum % 10 === 0) {
      await new Promise((resolve) => setImmediate(resolve));
    }
  }

  const elapsed = (Date.now() - startTime) / 1000;
  console.log(
    `[pgo-json] Completed ${totalOps} JSON operations in ${elapsed.toFixed(1)}s (${(totalOps / elapsed).toFixed(0)} ops/s)`,
  );
}

main().catch((err) => {
  console.error('[pgo-json] Error:', err);
  process.exit(1);
});