cloudbroker-sdk 0.4.0 → 0.6.0

package/src/test.js

@@ -173,5 +173,321 @@ assert.strictEqual(ctxEvent.product, "Billing",     `product do contexto esperad
 assert.strictEqual(ctxEvent.team,    "Plataforma",  `team do contexto esperado, veio ${ctxEvent.team}`);
 console.log("✅ expressMiddleware: label/product/team do contexto aplicados sem cb* explícito");
 
+// 4) CloudBrokerAI.wrap — label de código nas chamadas de IA (mesma
+// convenção do wrapAWS: explícito na chamada > contexto cbStore > nenhum),
+// pra agregar custo de IA junto com custo de nuvem na visão "Custo por Código".
+const capturedAi = [];
+globalThis.fetch = async (url, opts) => {
+  if (String(url).includes("/api/ai/events")) {
+    capturedAi.push(JSON.parse(opts.body));
+  }
+  return { ok: true, status: 200, json: async () => ({}) };
+};
+
+let sawOpenAiOptions;
+const mockOpenAI2 = {
+  chat: {
+    completions: {
+      create: async (params, options) => {
+        sawOpenAiOptions = options;
+        return {
+          model: params.model,
+          choices: [{ message: { role: "assistant", content: "ok" } }],
+          usage: { prompt_tokens: 10, completion_tokens: 5 },
+        };
+      },
+    },
+  },
+};
+const wrappedAi = CloudBrokerAI.wrap(mockOpenAI2, {
+  apiKey: "cb-test-key", product: "FinOps Advisor", team: "platform", debug: true,
+});
+
+await wrappedAi.chat.completions.create(
+  { model: "gpt-4o", messages: [{ role: "user", content: "x" }] },
+  { cbLabel: "finops-advisor:intent-classify" }
+);
+assert.strictEqual(sawOpenAiOptions, undefined, "cbLabel não pode vazar pro SDK do provider");
+await new Promise((r) => setTimeout(r, 50));
+assert.strictEqual(capturedAi.length, 1, `esperado 1 evento de IA, veio ${capturedAi.length}`);
+assert.strictEqual(capturedAi[0].events[0].label, "finops-advisor:intent-classify");
+console.log("✅ CloudBrokerAI.wrap: label explícito (cbLabel) capturado, sem vazar pro provider");
+
+// label via contexto (cbStore, mesmo ALS de CloudBrokerCloud.expressMiddleware)
+const mw2 = CloudBrokerCloud.expressMiddleware({ label: "finops-advisor:root-cause-agent" });
+await new Promise((resolve) => {
+  mw2({ method: "POST", path: "/api/chat/response" }, {}, async () => {
+    await wrappedAi.chat.completions.create({ model: "gpt-4o", messages: [{ role: "user", content: "y" }] });
+    resolve();
+  });
+});
+await new Promise((r) => setTimeout(r, 50));
+assert.strictEqual(capturedAi[1].events[0].label, "finops-advisor:root-cause-agent");
+console.log("✅ CloudBrokerAI.wrap: label via contexto cbStore (sem cbLabel explícito)");
+
+// ─── AZURE (wrapAzure — Blob Storage + Cosmos DB) ──────────────────────────────
+console.log("\n☁️  Testando wrapAzure (Blob + Cosmos)...");
+
+// 5) Tabela de preços Azure
+const blobW = estimateCloudCost({ provider: "azure", service: "blob", operation: "uploadData", requests: 1 });
+assert.strictEqual(blobW.billingUnit, "blob-write");
+assert.ok(Math.abs(blobW.costUSD - 0.055 / 10_000) < 1e-12, `blob write veio ${blobW.costUSD}`);
+
+const blobR = estimateCloudCost({ provider: "azure", service: "blob", operation: "download", requests: 1, bytesOut: 1024 * 1024 * 1024 });
+assert.strictEqual(blobR.billingUnit, "blob-read");
+assert.ok(Math.abs(blobR.costUSD - (0.0044 / 10_000 + 0.087)) < 1e-9, `blob read+transfer veio ${blobR.costUSD}`);
+
+const blobDel = estimateCloudCost({ provider: "azure", service: "blob", operation: "delete", requests: 1 });
+assert.strictEqual(blobDel.billingUnit, "blob-free");
+assert.strictEqual(blobDel.costUSD, 0);
+
+const blobList = estimateCloudCost({ provider: "azure", service: "blob", operation: "listBlobsFlat", requests: 1 });
+assert.strictEqual(blobList.billingUnit, "blob-list");
+
+const cosmosReal = estimateCloudCost({ provider: "azure", service: "cosmosdb", operation: "items.create", requestCharge: 7.43 });
+assert.strictEqual(cosmosReal.billingUnit, "cosmos-ru");
+assert.ok(Math.abs(cosmosReal.costUSD - 7.43 * 0.25 / 1_000_000) < 1e-15, `cosmos RU real veio ${cosmosReal.costUSD}`);
+
+const cosmosEst = estimateCloudCost({ provider: "azure", service: "cosmosdb", operation: "items.create" });
+assert.strictEqual(cosmosEst.billingUnit, "cosmos-ru-est");
+assert.ok(Math.abs(cosmosEst.costUSD - 5 * 0.25 / 1_000_000) < 1e-15, `cosmos RU fallback veio ${cosmosEst.costUSD}`);
+console.log("✅ estimateCloudCost azure: blob write/read+transfer/delete-free/list, cosmos RU real/fallback");
+
+// 5b) Região sem tabela de preço NÃO pode ser precificada como eastus2 — um app
+// em brazilsouth receberia o custo de outra região apresentado como o dele.
+const brs = estimateCloudCost({ provider: "azure", service: "blob", operation: "uploadData", region: "brazilsouth" });
+assert.strictEqual(brs.costUSD, null, `região sem preço deve dar custo null, veio ${brs.costUSD}`);
+assert.strictEqual(brs.billingUnit, "blob-region-unpriced");
+console.log("✅ região Azure sem tabela: custo null + unidade explícita (não finge eastus2)");
+
+// 6) Blob — cadeia de fábricas, cbLabel não vaza, bytes medidos do argumento certo
+captured.length = 0;
+globalThis.fetch = async (url, opts) => {
+  if (String(url).includes("/api/cloud/events")) captured.push(JSON.parse(opts.body));
+  return { ok: true, status: 200, json: async () => ({}) };
+};
+
+let sawBlobOptions, sawUploadArgs;
+class BlockBlobClient {
+  async uploadData(data, options) { sawBlobOptions = options; return { etag: "0x1" }; }
+  async download() { return { contentLength: 4096 }; }
+  // getProperties devolve o TAMANHO DO BLOB, mas não transfere o blob.
+  async getProperties() { return { contentLength: 5 * 1024 * 1024 * 1024 }; }
+  async uploadBlockBlob(...args) { sawUploadArgs = args; return { etag: "0x2" }; }
+  async setMetadata(meta, options) { return { meta, options }; }
+}
+class ContainerClient {
+  getBlockBlobClient(_name) { return new BlockBlobClient(); }
+  listBlobsFlat() {
+    let i = 0;
+    return { async next() { return i++ < 2 ? { done: false, value: { name: `b${i}` } } : { done: true }; },
+             [Symbol.asyncIterator]() { return this; } };
+  }
+  async uploadBlockBlob(...args) { sawUploadArgs = args; return { etag: "0x2" }; }
+}
+class BlobServiceClient {
+  getContainerClient(_name) { return new ContainerClient(); }
+}
+
+const blobSvc = CloudBrokerCloud.wrapAzure(new BlobServiceClient(), {
+  apiKey: "cb-test-key", product: "checkout", team: "mobile", debug: true,
+});
+const blockBlob = blobSvc.getContainerClient("docs").getBlockBlobClient("nf.pdf");
+const upRes = await blockBlob.uploadData(Buffer.from("hello azure"), { cbLabel: "upload-nf-azure" });
+assert.strictEqual(upRes.etag, "0x1", "resultado original deve ser preservado");
+// O argumento NUNCA é removido: setMetadata() sem argumento apaga os metadados
+// do blob. O options segue existindo, só sem as chaves cb*.
+assert.deepStrictEqual(sawBlobOptions, {}, "options deve chegar sem cb*, mas deve chegar");
+
+const dlRes = await blockBlob.download();
+assert.strictEqual(dlRes.contentLength, 4096);
+
+await new Promise(r => setTimeout(r, 50));
+const azEvents = captured.flatMap(c => c.events);
+assert.strictEqual(azEvents.length, 2, `esperado 2 eventos (upload+download), veio ${azEvents.length}`);
+const [evUp, evDl] = azEvents;
+assert.strictEqual(evUp.provider, "azure");
+assert.strictEqual(evUp.service, "blob");
+assert.strictEqual(evUp.operation, "uploadData");
+assert.strictEqual(evUp.label, "upload-nf-azure");
+assert.strictEqual(evUp.product, "checkout");
+assert.strictEqual(evUp.bytesIn, Buffer.byteLength("hello azure"));
+assert.strictEqual(evUp.billingUnit, "blob-write");
+assert.strictEqual(evDl.operation, "download");
+assert.strictEqual(evDl.bytesOut, 4096);
+assert.strictEqual(evDl.billingUnit, "blob-read");
+console.log("✅ wrapAzure blob: cadeia de fábricas, cb* sem vazar, options preservado, bytes in/out");
+
+// 6b) getProperties NÃO pode cobrar egress do tamanho do blob (custo inflado)
+captured.length = 0;
+await blockBlob.getProperties();
+await new Promise(r => setTimeout(r, 50));
+const evProps = captured.flatMap(c => c.events)[0];
+assert.strictEqual(evProps.operation, "getProperties");
+assert.strictEqual(evProps.bytesOut, 0, `getProperties não transfere o blob; bytesOut veio ${evProps.bytesOut}`);
+assert.ok(evProps.costUSD < 1e-6, `custo de metadado deve ser desprezível, veio ${evProps.costUSD}`);
+console.log("✅ getProperties: sem egress do tamanho do blob (custo de metadado, não de 5 GB)");
+
+// 6c) bytesIn vem do argumento de CORPO declarado, não da primeira string
+// (em uploadBlockBlob a primeira string é o NOME do blob)
+captured.length = 0;
+await blobSvc.getContainerClient("docs").uploadBlockBlob("relatorio-financeiro-2026-07.pdf", Buffer.alloc(10 * 1024 * 1024), 10 * 1024 * 1024);
+await new Promise(r => setTimeout(r, 50));
+const evBlockUp = captured.flatMap(c => c.events)[0];
+assert.strictEqual(evBlockUp.bytesIn, 10 * 1024 * 1024, `bytesIn deve ser o corpo (10MB), veio ${evBlockUp.bytesIn}`);
+console.log("✅ bytesIn: medido do argumento de corpo, não do nome do blob");
+
+// 6d) list é LAZY — nenhum HTTP na criação do iterator. Evento só quando a
+// página é de fato buscada (senão emitia custo de operação que nunca ocorreu).
+captured.length = 0;
+const neverUsed = blobSvc.getContainerClient("docs").listBlobsFlat();
+await new Promise(r => setTimeout(r, 50));
+assert.strictEqual(captured.length, 0, "iterator criado e não consumido não pode gerar custo");
+for await (const _b of neverUsed) { /* consome */ }
+await new Promise(r => setTimeout(r, 50));
+const listEvents = captured.flatMap(c => c.events);
+assert.ok(listEvents.length >= 1, "consumir o iterator deve gerar evento de list");
+assert.strictEqual(listEvents[0].billingUnit, "blob-list");
+console.log("✅ list: sem custo fabricado — evento só quando a página é buscada");
+
+// 7) Cosmos — requestCharge REAL vira custo; iterator de query rastreado
+captured.length = 0;
+let sawCreateArgs;
+class Item {
+  async read() { return { requestCharge: 1.0, resource: { id: "x" } }; }
+}
+class Container {
+  constructor() {
+    this.items = {
+      create: async (...args) => { sawCreateArgs = args; return { requestCharge: 7.43, resource: { id: "y" } }; },
+      query:  (_q) => ({ fetchAll: async () => ({ requestCharge: 3.2, resources: [] }) }),
+      bulk:   async (_ops) => ([{ requestCharge: 5 }, { requestCharge: 6 }]),
+    };
+  }
+  item(_id, _pk) { return new Item(); }
+  // control-plane: lê a definição do CONTAINER, não de um item
+  async read() { return { requestCharge: 2.0, resource: { id: "orders" } }; }
+}
+class Database {
+  container(_id) { return new Container(); }
+  async read() { return { requestCharge: 1.5, resource: { id: "db" } }; }
+}
+class CosmosClient { database(_id) { return new Database(); } }
+
+const cosmos = CloudBrokerCloud.wrapAzure(new CosmosClient(), {
+  apiKey: "cb-test-key", product: "checkout", team: "mobile",
+});
+const cont = cosmos.database("db").container("orders");
+const createRes = await cont.items.create({ id: "y" }, { cbLabel: "criar-pedido" });
+assert.strictEqual(createRes.resource.id, "y");
+await cont.item("x", "pk").read();
+await cont.items.query("SELECT * FROM c").fetchAll();
+
+await new Promise(r => setTimeout(r, 50));
+const cosmosEvents = captured.flatMap(c => c.events);
+assert.strictEqual(cosmosEvents.length, 3, `esperado 3 eventos cosmos, veio ${cosmosEvents.length}`);
+const [evCreate, evRead, evQuery] = cosmosEvents;
+assert.strictEqual(evCreate.service, "cosmosdb");
+assert.strictEqual(evCreate.operation, "items.create");
+assert.strictEqual(evCreate.label, "criar-pedido");
+assert.strictEqual(evCreate.billingUnit, "cosmos-ru");
+assert.ok(Math.abs(evCreate.costUSD - 7.43 * 0.25 / 1_000_000) < 1e-15, `custo RU real veio ${evCreate.costUSD}`);
+assert.strictEqual(evRead.operation, "item.read");
+assert.strictEqual(evQuery.operation, "items.query.fetchAll");
+assert.ok(Math.abs(evQuery.costUSD - 3.2 * 0.25 / 1_000_000) < 1e-15, `custo do query veio ${evQuery.costUSD}`);
+console.log("✅ wrapAzure cosmos: requestCharge real → custo, item.read, query iterator");
+
+// 7b) O DOCUMENTO do cliente nunca é inspecionado nem alterado — um campo
+// chamado cbLabel no corpo tem que ser gravado como veio.
+captured.length = 0;
+const docComCampoColidindo = { id: "z", cbLabel: "campo-de-negocio-do-cliente", valor: 10 };
+await cont.items.create(docComCampoColidindo);
+assert.deepStrictEqual(
+  sawCreateArgs[0],
+  { id: "z", cbLabel: "campo-de-negocio-do-cliente", valor: 10 },
+  "documento do cliente não pode perder campo por colisão de nome",
+);
+await new Promise(r => setTimeout(r, 50));
+assert.strictEqual(captured.flatMap(c => c.events)[0].label, null, "campo do corpo não vira label");
+console.log("✅ documento do cliente intacto: cb* no corpo não é lido nem removido");
+
+// 7c) Container.read()/Database.read() são control-plane — não podem sair
+// rotulados como item.read (operação errada na tela de custo por trecho).
+captured.length = 0;
+await cont.read();
+await cosmos.database("db").read();
+await new Promise(r => setTimeout(r, 50));
+const cpEvents = captured.flatMap(c => c.events);
+assert.strictEqual(cpEvents[0].operation, "container.read", `veio ${cpEvents[0].operation}`);
+assert.strictEqual(cpEvents[1].operation, "database.read", `veio ${cpEvents[1].operation}`);
+console.log("✅ cosmos: container.read/database.read não são confundidos com item.read");
+
+// 7d) bulk soma o requestCharge de cada operação (senão 1000 escritas = 1 leitura)
+captured.length = 0;
+await cont.items.bulk([{ operationType: "Create" }, { operationType: "Create" }]);
+await new Promise(r => setTimeout(r, 50));
+const evBulk = captured.flatMap(c => c.events)[0];
+assert.strictEqual(evBulk.operation, "items.bulk");
+assert.strictEqual(evBulk.billingUnit, "cosmos-ru", "bulk deve usar RU medida, não estimativa");
+assert.ok(Math.abs(evBulk.costUSD - 11 * 0.25 / 1_000_000) < 1e-15, `bulk deve somar 5+6 RU, veio ${evBulk.costUSD}`);
+console.log("✅ cosmos bulk: RUs somadas por operação");
+
+// 8) Robustez — a instrumentação NUNCA pode quebrar a aplicação do cliente.
+// Este é o requisito mais importante: o SDK roda dentro da produção dele.
+captured.length = 0;
+class BlobQuebrado {
+  async uploadData() {
+    // Resposta com propriedade lazy que lança ao ser lida (padrão em SDKs
+    // de streaming). A operação JÁ ACONTECEU no Azure quando isso é lido.
+    return { etag: "ok", get contentLength() { throw new Error("propriedade lazy do SDK lançou"); } };
+  }
+}
+class ContainerQuebrado { getBlockBlobClient() { return new BlobQuebrado(); } }
+class BlobServiceClient2 { getContainerClient() { return new ContainerQuebrado(); } }
+Object.defineProperty(BlobServiceClient2, "name", { value: "BlobServiceClient" });
+Object.defineProperty(ContainerQuebrado, "name", { value: "ContainerClient" });
+Object.defineProperty(BlobQuebrado, "name", { value: "BlockBlobClient" });
+
+const svcQuebrado = CloudBrokerCloud.wrapAzure(new BlobServiceClient2(), { apiKey: "cb-test-key" });
+const r8 = await svcQuebrado.getContainerClient("c").getBlockBlobClient("b").uploadData(Buffer.from("x"));
+assert.strictEqual(r8.etag, "ok", "erro na instrumentação não pode virar erro da aplicação do cliente");
+console.log("✅ robustez: exceção na leitura do resultado não vaza pro app do cliente");
+
+// options com getter que lança, ANTES da chamada real
+class BlobGetterRuim {
+  async uploadData(_d, _o) { return { etag: "ok2" }; }
+}
+Object.defineProperty(BlobGetterRuim, "name", { value: "BlockBlobClient" });
+const bad = CloudBrokerCloud.wrapAzure(new BlobGetterRuim(), { apiKey: "cb-test-key" });
+const optsRuim = Object.defineProperty({}, "cbLabel", { get() { throw new Error("getter ruim"); }, enumerable: true });
+const r8b = await bad.uploadData(Buffer.from("x"), optsRuim);
+assert.strictEqual(r8b.etag, "ok2", "erro ao extrair label não pode impedir a operação real");
+console.log("✅ robustez: falha na extração de label não impede a chamada Azure");
+
+// 8b) Client congelado pelo cliente: a atribuição in-place lançaria (strict
+// mode). Instrumentação nunca pode derrubar a app — avisa e devolve original.
+class BlobCongelado { async uploadData() { return { etag: "frozen-ok" }; } }
+Object.defineProperty(BlobCongelado, "name", { value: "BlockBlobClient" });
+const congelado = Object.freeze(new BlobCongelado());
+const warnsFrozen = [];
+const warnFrozenOrig = console.warn;
+console.warn = (...a) => warnsFrozen.push(a.join(" "));
+const wrappedFrozen = CloudBrokerCloud.wrapAzure(congelado, { apiKey: "cb-test-key" });
+console.warn = warnFrozenOrig;
+const rFrozen = await wrappedFrozen.uploadData(Buffer.from("x"));
+assert.strictEqual(rFrozen.etag, "frozen-ok", "client congelado deve seguir funcionando");
+assert.ok(warnsFrozen.some(w => w.includes("congelado")), "deve avisar que não vai rastrear");
+console.log("✅ robustez: client congelado não quebra a aplicação (avisa e não rastreia)");
+
+// 9) Client não reconhecido → retorna original intocado (e avisa alto)
+class MinhaClasseQualquer { async foo() { return 42; } }
+const warns = [];
+const origWarn = console.warn;
+console.warn = (...a) => warns.push(a.join(" "));
+const untouched = CloudBrokerCloud.wrapAzure(new MinhaClasseQualquer(), { apiKey: "cb-test-key" });
+console.warn = origWarn;
+assert.strictEqual(await untouched.foo(), 42);
+assert.ok(warns.some(w => w.includes("não reconhecido")), "deve avisar mesmo sem debug:true");
+console.log("✅ wrapAzure: client não reconhecido passa intocado, com aviso incondicional");
 globalThis.fetch = realFetch;
 console.log("\n🎉 Todos os testes passaram.");

package/src/wrapper.js

@@ -5,6 +5,7 @@
 
 import { CloudBrokerClient } from "./client.js";
 import { PRICING } from "./pricing.js";
+import { cbStore } from "./context.js";
 
 export class CloudBrokerAI {
   /**
@@ -17,6 +18,13 @@ export class CloudBrokerAI {
    * @param {string} options.team      — nome do squad (ex: "mobile")
    * @param {string} options.endpoint  — endpoint CloudBroker (opcional)
    * @param {boolean} options.debug    — logs de debug (opcional)
+   *
+   * Label opcional do trecho de código, pra agregar custo de IA junto com
+   * custo de nuvem na mesma visão "Custo por Código" (mesma convenção de
+   * CloudBrokerCloud.wrapAWS):
+   *   await client.chat.completions.create(params, { cbLabel: "checkout:resumo-pedido" });
+   *   await client.messages.create(params, { cbLabel: "checkout:resumo-pedido" });
+   * Ou via CloudBrokerCloud.expressMiddleware() (contexto automático por requisição).
    */
   static wrap(client, options = {}) {
     const { apiKey, product, team, endpoint, debug = false } = options;
@@ -77,6 +85,11 @@ export class CloudBrokerAI {
 
     client.chat.completions.create = async (params, options) => {
       const start = Date.now();
+      // Mesma precedência de cloud-wrapper.js: explícito na chamada > contexto
+      // cbStore (expressMiddleware) > nenhum. Nunca vaza cbLabel pro SDK do provider.
+      const cbLabel = options?.cbLabel || cbStore.getStore()?.label || null;
+      const { cbLabel: _l, ...providerOptions } = options || {};
+      const fwdOptions = Object.keys(providerOptions).length ? providerOptions : undefined;
 
       // ── Streaming: pede usage no chunk final e instrumenta o iterador ────────
       if (params?.stream) {
@@ -84,7 +97,7 @@ export class CloudBrokerAI {
           ...params,
           stream_options: { include_usage: true, ...(params.stream_options || {}) },
         };
-        const stream = await originalCreate(streamParams, options);
+        const stream = await originalCreate(streamParams, fwdOptions);
 
         let model = params.model || "unknown";
         let inputTokens = 0, outputTokens = 0;
@@ -104,6 +117,7 @@ export class CloudBrokerAI {
               model,
               product:     product || null,
               team:        team    || null,
+              label:       cbLabel,
               inputTokens,
               outputTokens,
               totalTokens: inputTokens + outputTokens,
@@ -121,7 +135,7 @@ export class CloudBrokerAI {
       }
 
       // ── Não-streaming ───────────────────────────────────────────────────────
-      const res = await originalCreate(params, options);
+      const res = await originalCreate(params, fwdOptions);
       const ms  = Date.now() - start;
 
       // Fire-and-forget
@@ -137,6 +151,7 @@ export class CloudBrokerAI {
           model,
           product:       product || null,
           team:          team    || null,
+          label:         cbLabel,
           inputTokens,
           outputTokens,
           totalTokens:   inputTokens + outputTokens,
@@ -159,10 +174,13 @@ export class CloudBrokerAI {
 
     client.messages.create = async (params, options) => {
       const start = Date.now();
+      const cbLabel = options?.cbLabel || cbStore.getStore()?.label || null;
+      const { cbLabel: _l, ...providerOptions } = options || {};
+      const fwdOptions = Object.keys(providerOptions).length ? providerOptions : undefined;
 
       // ── Streaming: acumula usage dos eventos message_start / message_delta ───
       if (params?.stream) {
-        const stream = await originalCreate(params, options);
+        const stream = await originalCreate(params, fwdOptions);
 
         let model = params.model || "unknown";
         let inputTokens = 0, outputTokens = 0;
@@ -185,6 +203,7 @@ export class CloudBrokerAI {
               model,
               product:     product || null,
               team:        team    || null,
+              label:       cbLabel,
               inputTokens,
               outputTokens,
               totalTokens: inputTokens + outputTokens,
@@ -202,7 +221,7 @@ export class CloudBrokerAI {
       }
 
       // ── Não-streaming ───────────────────────────────────────────────────────
-      const res = await originalCreate(params, options);
+      const res = await originalCreate(params, fwdOptions);
       const ms  = Date.now() - start;
 
       try {
@@ -217,6 +236,7 @@ export class CloudBrokerAI {
           model,
           product:       product || null,
           team:          team    || null,
+          label:         cbLabel,
           inputTokens,
           outputTokens,
           totalTokens:   inputTokens + outputTokens,