weflayr 0.24.0 → 0.26.0

package/src/setup.js

@@ -1,167 +0,0 @@
-'use strict';
-
-const { trace } = require('@opentelemetry/api');
-const { NodeTracerProvider } = require('@opentelemetry/sdk-trace-node');
-const { resourceFromAttributes } = require('@opentelemetry/resources');
-
-const { buildExporter } = require('./otel/exporter');
-const { CONTENT_CAPTURE_ENV, WeflayrSpanProcessor } = require('./otel/span-processor');
-const { debug } = require('./logger');
-const { version: SDK_VERSION } = require('../package.json');
-
-const SDK_LANGUAGE = 'javascript';
-const DEFAULT_BASE_URL = 'https://api.weflayr.com';
-
-const _state = {
-  tracerProvider: null,
-  processor: null,
-  beforeExitListener: null,
-};
-
-// `trace.getTracerProvider()` returns a ProxyTracerProvider that forwards to
-// whoever called `.register()` last. Unwrap it to reach the real provider.
-function _unwrapTracerProvider(p) {
-  if (p && typeof p.getDelegate === 'function') {
-    return p.getDelegate();
-  }
-  return p;
-}
-
-// `NodeTracerProvider` 2.x dropped the public `addSpanProcessor` API —
-// processors are construction-time only. To attach to a provider somebody
-// else owns, we splice into the internal MultiSpanProcessor. This matches
-// the actual public OTel JS guidance for composing post-construction.
-function _attachProcessorToExistingProvider(provider, processor) {
-  if (!provider) return false;
-  if (typeof provider.addSpanProcessor === 'function') {
-    provider.addSpanProcessor(processor);
-    return true;
-  }
-  const multi = provider._activeSpanProcessor;
-  if (multi && Array.isArray(multi._spanProcessors)) {
-    multi._spanProcessors.push(processor);
-    return true;
-  }
-  return false;
-}
-
-/**
- * Configure the Weflayr SDK.
- *
- * Call once per process, before `autoInstrument`. For per-request or
- * per-tenant data in a long-running server use `propagateMetadata(...)` —
- * it stores metadata in OTel's `Context` (built on AsyncLocalStorage) and
- * isolates correctly across concurrent requests.
- *
- * Calling `setup` again is supported but replaces the previous
- * configuration: the prior processor is shut down and detached so we never
- * stack exporters (which would otherwise double-export every span and leak
- * HTTP pools).
- */
-function setup(options) {
-  const opts = options || {};
-  const apiKey = opts.apiKey || process.env.WEFLAYR_API_KEY;
-  if (typeof apiKey !== 'string' || !apiKey) {
-    throw new Error(
-      'weflayr.setup: `apiKey` is required (pass it explicitly or set WEFLAYR_API_KEY)'
-    );
-  }
-  options = { ...opts, apiKey };
-
-  if (options.captureMessageContent === false) {
-    process.env[CONTENT_CAPTURE_ENV] = 'false';
-  } else if (options.captureMessageContent === true) {
-    process.env[CONTENT_CAPTURE_ENV] = 'true';
-  }
-
-  _detachPreviousWeflayrProcessor();
-
-  const baseUrl = options.baseUrl || process.env.WEFLAYR_BASE_URL || DEFAULT_BASE_URL;
-
-  const exporter = buildExporter({
-    baseUrl,
-    apiKey: options.apiKey,
-    warnOnExportError: options.warnOnExportError !== false,
-  });
-
-  const processor = new WeflayrSpanProcessor({
-    exporter,
-    exportMode: options.exportMode || 'batch',
-    defaultTags: options.defaultTags || {},
-    mask: options.mask,
-  });
-
-  // Adopt an existing TracerProvider when there is one — e.g. the user already
-  // configured Datadog/Honeycomb/OTel, or called weflayr.setup() before.
-  // provider.register() silently refuses to override the proxy if another
-  // provider is already wired in, so naively creating a new provider would
-  // leave our processor attached to a dead one and we'd drop every LLM span.
-  const currentTracerProvider = _unwrapTracerProvider(trace.getTracerProvider());
-  let tracerProvider;
-  if (_attachProcessorToExistingProvider(currentTracerProvider, processor)) {
-    tracerProvider = currentTracerProvider;
-  } else {
-    tracerProvider = new NodeTracerProvider({
-      resource: resourceFromAttributes({
-        sdk_version: SDK_VERSION,
-        sdk_language: SDK_LANGUAGE,
-      }),
-      spanProcessors: [processor],
-    });
-    tracerProvider.register();
-  }
-
-  // beforeExit fires when the event loop empties on a clean exit, giving us a
-  // last async tick to drain buffered spans. It does NOT fire on process.exit()
-  // or uncaught fatals — callers handling those paths still need to call flush
-  // explicitly (e.g. in a finally) for the OTLP HTTP request to complete.
-  if (!_state.beforeExitListener) {
-    _state.beforeExitListener = async () => {
-      try {
-        await flush();
-      } catch {
-        // best-effort: process is already winding down.
-      }
-    };
-    process.on('beforeExit', _state.beforeExitListener);
-  }
-
-  _state.tracerProvider = tracerProvider;
-  _state.processor = processor;
-  debug(
-    'setup ready: baseUrl=%s exportMode=%s defaultTags=%d',
-    baseUrl,
-    options.exportMode || 'batch',
-    Object.keys(options.defaultTags || {}).length
-  );
-}
-
-async function flush() {
-  if (!_state.processor) return;
-  debug('flush: forcing exporter flush');
-  await _state.processor.forceFlush();
-}
-
-// Shut down + detach the prior weflayr processor — idempotency for setup().
-// Without this, calling setup() twice (key rotation, hot reload, tests that
-// reconfigure) would leave the first processor wired in alongside the new
-// one, double-exporting every span and leaking exporter HTTP pools.
-function _detachPreviousWeflayrProcessor() {
-  const previousProcessor = _state.processor;
-  if (!previousProcessor) return;
-  const tp = _state.tracerProvider;
-  const multi = tp && tp._activeSpanProcessor;
-  if (multi && Array.isArray(multi._spanProcessors)) {
-    multi._spanProcessors = multi._spanProcessors.filter(
-      (processor) => processor !== previousProcessor
-    );
-  }
-  try {
-    previousProcessor.shutdown();
-  } catch {
-    // best-effort cleanup.
-  }
-  _state.processor = null;
-}
-
-module.exports = { setup, flush, _state };

package/tests/api/index.test.js

@@ -1,437 +0,0 @@
-'use strict';
-
-// Tests for the public-API client: auth and base-URL wiring of the
-// client facade, plus the request/response wiring of every generated
-// endpoint (server behavior is covered by the dashboard's app_api tests).
-
-const { test } = require('node:test');
-const assert = require('node:assert/strict');
-const http = require('node:http');
-
-const weflayr = require('../../src/index');
-const { api } = weflayr;
-
-// A client whose server records requests and returns a canned response.
-async function withClientReturning(responseBody, statusCode, run, clientOptions = {}) {
-  const seenRequests = [];
-  const server = http.createServer((request, response) => {
-    let requestBody = '';
-    request.on('data', (chunk) => {
-      requestBody += chunk;
-    });
-    request.on('end', () => {
-      seenRequests.push({
-        method: request.method,
-        url: request.url,
-        authorization: request.headers.authorization,
-        body: requestBody === '' ? null : JSON.parse(requestBody),
-      });
-      response.statusCode = statusCode;
-      response.setHeader('content-type', 'application/json');
-      response.end(JSON.stringify(responseBody));
-    });
-  });
-  await new Promise((resolve) => server.listen(0, resolve));
-  const client = api.client({
-    apiKey: 'wf-test-key',
-    ...clientOptions,
-    baseUrl: `http://127.0.0.1:${server.address().port}/api`,
-  });
-  try {
-    await run(client, seenRequests);
-  } finally {
-    server.close();
-  }
-}
-
-// ── client facade ─────────────────────────────────────────────────────────
-
-test('client sends the bearer key to the configured host', async () => {
-  await withClientReturning({ rows: [] }, 200, async (client, seenRequests) => {
-    const { data } = await api.getRevenue({ client, throwOnError: true });
-    assert.deepEqual(data, { rows: [] });
-    assert.deepEqual(seenRequests, [
-      { method: 'GET', url: '/api/revenue/', authorization: 'Bearer wf-test-key', body: null },
-    ]);
-  });
-});
-
-test('weflayr.client is the same function as api.client', () => {
-  assert.equal(weflayr.client, api.client);
-});
-
-test('client defaults to the production API host', () => {
-  const client = api.client({ apiKey: 'wf-test-key' });
-  assert.equal(client.getConfig().baseUrl, 'https://app.weflayr.com/api');
-});
-
-test('client throws without apiKey', () => {
-  const saved = process.env.WEFLAYR_API_KEY;
-  delete process.env.WEFLAYR_API_KEY;
-  try {
-    assert.throws(() => api.client(), /apiKey/);
-  } finally {
-    if (saved !== undefined) process.env.WEFLAYR_API_KEY = saved;
-  }
-});
-
-test('client picks up apiKey from WEFLAYR_API_KEY env var', async () => {
-  process.env.WEFLAYR_API_KEY = 'env-key';
-  try {
-    await withClientReturning(
-      { rows: [] },
-      200,
-      async (client, seenRequests) => {
-        await api.getRevenue({ client, throwOnError: true });
-        assert.equal(seenRequests[0].authorization, 'Bearer env-key');
-      },
-      { apiKey: undefined }
-    );
-  } finally {
-    delete process.env.WEFLAYR_API_KEY;
-  }
-});
-
-// ── Revenue ───────────────────────────────────────────────────────────────────
-
-test('setRevenue posts the rows in snake_case and parses the booked count', async () => {
-  await withClientReturning({ ok: true, rows_inserted: 2 }, 200, async (client, seenRequests) => {
-    const rows = [
-      { customerName: 'c_1', amount: 1200.5, month: '2026-06' },
-      { customerName: 'c_2', amount: 800, month: '2026-06' },
-    ];
-    const { data } = await api.setRevenue({ client, throwOnError: true, body: { rows } });
-    assert.deepEqual(data, { ok: true, rowsInserted: 2 });
-    const request = seenRequests[0];
-    assert.equal(request.method, 'POST');
-    assert.equal(request.url, '/api/revenue/');
-    assert.deepEqual(request.body, {
-      rows: [
-        { customer_name: 'c_1', amount: 1200.5, month: '2026-06' },
-        { customer_name: 'c_2', amount: 800, month: '2026-06' },
-      ],
-    });
-  });
-});
-
-test('setRevenue posts the revenueId in snake_case and the upsert flag', async () => {
-  await withClientReturning({ ok: true, rows_inserted: 1 }, 200, async (client, seenRequests) => {
-    const rows = [
-      {
-        revenueId: 'b3f2b160-6e12-4f1a-9c3d-0a2e7c9b5d41',
-        customerName: 'c_1',
-        amount: 1300,
-        month: '2026-06',
-      },
-    ];
-    const { data } = await api.setRevenue({
-      client,
-      throwOnError: true,
-      body: { upsert: true, rows },
-    });
-    assert.deepEqual(data, { ok: true, rowsInserted: 1 });
-    assert.deepEqual(seenRequests[0].body, {
-      upsert: true,
-      rows: [
-        {
-          revenue_id: 'b3f2b160-6e12-4f1a-9c3d-0a2e7c9b5d41',
-          customer_name: 'c_1',
-          amount: 1300,
-          month: '2026-06',
-        },
-      ],
-    });
-  });
-});
-
-test('getRevenue parses the returned rows into camelCase', async () => {
-  const wireRow = {
-    customer_name: 'c_1',
-    metric_name: 'revenue',
-    month: '2026-06',
-    amount: 1200.5,
-    source: 'api',
-  };
-  await withClientReturning({ rows: [wireRow] }, 200, async (client) => {
-    const { data } = await api.getRevenue({ client, throwOnError: true });
-    assert.deepEqual(data.rows, [
-      {
-        customerName: 'c_1',
-        metricName: 'revenue',
-        month: '2026-06',
-        amount: 1200.5,
-        source: 'api',
-      },
-    ]);
-  });
-});
-
-test('getRevenue sends the customerNames filter as repeated params', async () => {
-  await withClientReturning({ rows: [] }, 200, async (client, seenRequests) => {
-    const { data } = await api.getRevenue({
-      client,
-      throwOnError: true,
-      query: { customerNames: ['c_1', 'c_2'] },
-    });
-    assert.deepEqual(data, { rows: [] });
-    const query = new URL(seenRequests[0].url, 'http://x').searchParams;
-    assert.deepEqual(query.getAll('customer_names'), ['c_1', 'c_2']);
-  });
-});
-
-test('deleteRevenue sends the customerNames filter and parses the deleted count', async () => {
-  await withClientReturning({ ok: true, rows_deleted: 2 }, 200, async (client, seenRequests) => {
-    const { data } = await api.deleteRevenue({
-      client,
-      throwOnError: true,
-      query: { customerNames: ['c_1', 'c_2'] },
-    });
-    assert.deepEqual(data, { ok: true, rowsDeleted: 2 });
-    const request = seenRequests[0];
-    assert.equal(request.method, 'DELETE');
-    const url = new URL(request.url, 'http://x');
-    assert.equal(url.pathname, '/api/revenue/');
-    assert.deepEqual(url.searchParams.getAll('customer_names'), ['c_1', 'c_2']);
-  });
-});
-
-// ── Key metrics ───────────────────────────────────────────────────────────────
-
-test('setKeyMetrics posts the rows in snake_case and parses the booked count', async () => {
-  await withClientReturning({ ok: true, rows_inserted: 1 }, 200, async (client, seenRequests) => {
-    const rows = [{ userName: 'u_1', metricName: 'Meetings booked', amount: 3, month: '2026-06' }];
-    const { data } = await api.setKeyMetrics({ client, throwOnError: true, body: { rows } });
-    assert.deepEqual(data, { ok: true, rowsInserted: 1 });
-    const request = seenRequests[0];
-    assert.equal(request.method, 'POST');
-    assert.equal(request.url, '/api/key-metrics/');
-    assert.deepEqual(request.body, {
-      rows: [{ user_name: 'u_1', metric_name: 'Meetings booked', amount: 3, month: '2026-06' }],
-    });
-  });
-});
-
-test('getKeyMetrics parses the returned rows into camelCase', async () => {
-  const wireRow = {
-    user_name: 'u_1',
-    metric_name: 'Meetings booked',
-    month: '2026-06',
-    amount: 3.0,
-    source: 'api',
-  };
-  await withClientReturning({ rows: [wireRow] }, 200, async (client) => {
-    const { data } = await api.getKeyMetrics({ client, throwOnError: true });
-    assert.deepEqual(data.rows, [
-      {
-        userName: 'u_1',
-        metricName: 'Meetings booked',
-        month: '2026-06',
-        amount: 3.0,
-        source: 'api',
-      },
-    ]);
-  });
-});
-
-test('getKeyMetrics sends the userNames filter as repeated params', async () => {
-  await withClientReturning({ rows: [] }, 200, async (client, seenRequests) => {
-    const { data } = await api.getKeyMetrics({
-      client,
-      throwOnError: true,
-      query: { userNames: ['u_1', 'u_2'] },
-    });
-    assert.deepEqual(data, { rows: [] });
-    const query = new URL(seenRequests[0].url, 'http://x').searchParams;
-    assert.deepEqual(query.getAll('user_names'), ['u_1', 'u_2']);
-  });
-});
-
-test('setKeyMetrics surfaces a 422 and its details', async () => {
-  const rejection = {
-    error: 'Invalid payload.',
-    detail: [{ field: 'rows.0.metric_name', error: 'Unknown metric.' }],
-  };
-  await withClientReturning(rejection, 422, async (client) => {
-    const { error, response } = await api.setKeyMetrics({ client, body: { rows: [] } });
-    assert.equal(response.status, 422);
-    assert.deepEqual(error, rejection);
-  });
-});
-
-test('deleteKeyMetrics sends the userNames filter and parses the deleted count', async () => {
-  await withClientReturning({ ok: true, rows_deleted: 2 }, 200, async (client, seenRequests) => {
-    const { data } = await api.deleteKeyMetrics({
-      client,
-      throwOnError: true,
-      query: { userNames: ['u_1', 'u_2'] },
-    });
-    assert.deepEqual(data, { ok: true, rowsDeleted: 2 });
-    const request = seenRequests[0];
-    assert.equal(request.method, 'DELETE');
-    const url = new URL(request.url, 'http://x');
-    assert.equal(url.pathname, '/api/key-metrics/');
-    assert.deepEqual(url.searchParams.getAll('user_names'), ['u_1', 'u_2']);
-  });
-});
-
-// ── Margin ────────────────────────────────────────────────────────────────────
-
-test('getMargin parses the returned rows into camelCase', async () => {
-  const wireRow = {
-    customer_name: 'c_1',
-    revenue: 1000.0,
-    cost: 200.0,
-    margin: 800.0,
-    margin_pct: 80.0,
-    profitability_status: 'healthy',
-  };
-  await withClientReturning(
-    { rows: [wireRow], next_cursor: null, has_more: false },
-    200,
-    async (client) => {
-      const { data } = await api.getMargin({ client, throwOnError: true });
-      assert.deepEqual(data.rows, [
-        {
-          customerName: 'c_1',
-          revenue: 1000.0,
-          cost: 200.0,
-          margin: 800.0,
-          marginPct: 80.0,
-          profitabilityStatus: 'healthy',
-        },
-      ]);
-    }
-  );
-});
-
-test('getMargin sends the cursor and limit query params', async () => {
-  await withClientReturning(
-    { rows: [], next_cursor: 'Y19h', has_more: true },
-    200,
-    async (client, seenRequests) => {
-      const { data } = await api.getMargin({
-        client,
-        throwOnError: true,
-        query: { cursor: 'abc123', limit: 2 },
-      });
-      assert.equal(data.nextCursor, 'Y19h');
-      assert.equal(data.hasMore, true);
-      const query = new URL(seenRequests[0].url, 'http://x').searchParams;
-      assert.equal(query.get('cursor'), 'abc123');
-      assert.equal(query.get('limit'), '2');
-    }
-  );
-});
-
-test('getMargin sends the customerNames filter as repeated params', async () => {
-  await withClientReturning({ rows: [] }, 200, async (client, seenRequests) => {
-    const { data } = await api.getMargin({
-      client,
-      throwOnError: true,
-      query: { customerNames: ['c_1', 'c_2'] },
-    });
-    assert.deepEqual(data, { rows: [] });
-    const query = new URL(seenRequests[0].url, 'http://x').searchParams;
-    assert.deepEqual(query.getAll('customer_names'), ['c_1', 'c_2']);
-  });
-});
-
-test('getMargin sends the dateFrom/dateTo/applyCredits filters in snake_case', async () => {
-  await withClientReturning({ rows: [] }, 200, async (client, seenRequests) => {
-    await api.getMargin({
-      client,
-      throwOnError: true,
-      query: { dateFrom: '2026-06-01', dateTo: '2026-06-30', applyCredits: true },
-    });
-    const query = new URL(seenRequests[0].url, 'http://x').searchParams;
-    assert.equal(query.get('date_from'), '2026-06-01');
-    assert.equal(query.get('date_to'), '2026-06-30');
-    assert.equal(query.get('apply_credits'), 'true');
-  });
-});
-
-// ── Customer tags ─────────────────────────────────────────────────────────────
-
-test('setCustomersTags posts the customers in snake_case and parses the updated count', async () => {
-  await withClientReturning(
-    { ok: true, customers_updated: 1 },
-    200,
-    async (client, seenRequests) => {
-      const customers = [{ customerName: 'c_1', tags: { plan: 'pro' } }];
-      const { data } = await api.setCustomersTags({
-        client,
-        throwOnError: true,
-        body: { customers },
-      });
-      assert.deepEqual(data, { ok: true, customersUpdated: 1 });
-      const request = seenRequests[0];
-      assert.equal(request.method, 'POST');
-      assert.equal(request.url, '/api/customer-tags/');
-      assert.deepEqual(request.body, {
-        customers: [{ customer_name: 'c_1', tags: { plan: 'pro' } }],
-      });
-    }
-  );
-});
-
-test('setCustomersTags leaves tag keys untouched, even when they contain underscores', async () => {
-  await withClientReturning(
-    { ok: true, customers_updated: 1 },
-    200,
-    async (client, seenRequests) => {
-      const customers = [{ customerName: 'c_1', tags: { utm_source: 'ads', plan_tier: 'pro' } }];
-      await api.setCustomersTags({ client, throwOnError: true, body: { customers } });
-      assert.deepEqual(seenRequests[0].body, {
-        customers: [{ customer_name: 'c_1', tags: { utm_source: 'ads', plan_tier: 'pro' } }],
-      });
-    }
-  );
-});
-
-test('getCustomersTags parses the returned customers into camelCase', async () => {
-  const wireCustomer = { customer_name: 'c_1', tags: { plan: 'pro' } };
-  await withClientReturning(
-    { customers: [wireCustomer], next_cursor: null, has_more: false },
-    200,
-    async (client) => {
-      const { data } = await api.getCustomersTags({ client, throwOnError: true });
-      assert.deepEqual(data.customers, [{ customerName: 'c_1', tags: { plan: 'pro' } }]);
-    }
-  );
-});
-
-test('getCustomersTags sends the customerNames filter, leaving tag keys untouched', async () => {
-  const wireCustomer = { customer_name: 'c_1', tags: { plan: 'pro', utm_source: 'ads' } };
-  await withClientReturning(
-    { customers: [wireCustomer], next_cursor: null, has_more: false },
-    200,
-    async (client, seenRequests) => {
-      const { data } = await api.getCustomersTags({
-        client,
-        throwOnError: true,
-        query: { customerNames: ['c_1', 'c_2'] },
-      });
-      assert.deepEqual(data.customers, [
-        { customerName: 'c_1', tags: { plan: 'pro', utm_source: 'ads' } },
-      ]);
-      const query = new URL(seenRequests[0].url, 'http://x').searchParams;
-      assert.deepEqual(query.getAll('customer_names'), ['c_1', 'c_2']);
-    }
-  );
-});
-
-test('deleteCustomersTags sends the customerNames filter and parses the deleted count', async () => {
-  await withClientReturning({ ok: true, tags_deleted: 3 }, 200, async (client, seenRequests) => {
-    const { data } = await api.deleteCustomersTags({
-      client,
-      throwOnError: true,
-      query: { customerNames: ['c_1', 'c_2'] },
-    });
-    assert.deepEqual(data, { ok: true, tagsDeleted: 3 });
-    const request = seenRequests[0];
-    assert.equal(request.method, 'DELETE');
-    const url = new URL(request.url, 'http://x');
-    assert.equal(url.pathname, '/api/customer-tags/');
-    assert.deepEqual(url.searchParams.getAll('customer_names'), ['c_1', 'c_2']);
-  });
-});