OpenAI API 모델 및 기능별 비용 추적

{
  "provider": "openai",
  "model": "gpt-5",
  "input_tokens": 1250,
  "output_tokens": 340,
  "cost_usd": 0.0184,
  "latency_ms": 842,
  "status": "ok",
  "sample": true
}

SELECT
  model,
  COUNT(*) AS requests,
  SUM(input_tokens) AS input_tokens,
  SUM(output_tokens) AS output_tokens,
  ROUND(SUM(cost_usd), 4) AS total_cost_usd,
  ROUND(AVG(latency_ms), 0) AS average_latency_ms
FROM telemetry_quickstart
WHERE provider = 'openai'
GROUP BY model
ORDER BY total_cost_usd DESC;

npm install openai telemetry-sh

import OpenAI from "openai";
import telemetry from "telemetry-sh";

const openai = new OpenAI();
telemetry.init(process.env.TELEMETRY_API_KEY);

OPENAI_MODEL="YOUR_MODEL"
OPENAI_INPUT_USD_PER_MILLION="YOUR_CURRENT_INPUT_RATE"
OPENAI_CACHED_INPUT_USD_PER_MILLION="YOUR_CURRENT_CACHED_INPUT_RATE"
OPENAI_CACHE_WRITE_USD_PER_MILLION="YOUR_CURRENT_CACHE_WRITE_RATE"
OPENAI_OUTPUT_USD_PER_MILLION="YOUR_CURRENT_OUTPUT_RATE"
OPENAI_PRICING_VERSION="provider-price-sheet-reviewed-YYYY-MM-DD"

const pricing = {
  inputUsdPerMillion: Number(process.env.OPENAI_INPUT_USD_PER_MILLION),
  cachedInputUsdPerMillion: Number(
    process.env.OPENAI_CACHED_INPUT_USD_PER_MILLION
  ),
  cacheWriteUsdPerMillion: Number(
    process.env.OPENAI_CACHE_WRITE_USD_PER_MILLION
  ),
  outputUsdPerMillion: Number(process.env.OPENAI_OUTPUT_USD_PER_MILLION),
};

function estimateCostUsd({
  inputTokens,
  cachedInputTokens,
  cacheWriteTokens,
  outputTokens,
}) {
  const uncachedInputTokens = Math.max(
    0,
    inputTokens - cachedInputTokens - cacheWriteTokens
  );

  return (
    (uncachedInputTokens * pricing.inputUsdPerMillion +
      cachedInputTokens * pricing.cachedInputUsdPerMillion +
      cacheWriteTokens * pricing.cacheWriteUsdPerMillion +
      outputTokens * pricing.outputUsdPerMillion) /
    1_000_000
  );
}

async function createDraftReply({ input, teamId, userId, attempt = 1 }) {
  const model = process.env.OPENAI_MODEL;
  const startedAt = Date.now();

  try {
    const response = await openai.responses.create({
      model,
      input,
    });

    const inputTokens = response.usage?.input_tokens ?? 0;
    const outputTokens = response.usage?.output_tokens ?? 0;
    const cachedInputTokens =
      response.usage?.input_tokens_details?.cached_tokens ?? 0;
    const cacheWriteTokens =
      response.usage?.input_tokens_details?.cache_write_tokens ?? 0;
    const reasoningTokens =
      response.usage?.output_tokens_details?.reasoning_tokens ?? 0;
    const estimatedCostUsd = estimateCostUsd({
      inputTokens,
      cachedInputTokens,
      cacheWriteTokens,
      outputTokens,
    });

    await telemetry.log("llm_request_completed", {
      response_id: response.id,
      provider: "openai",
      model: response.model ?? model,
      feature: "draft_reply",
      team_id: teamId,
      user_id: userId,
      status: "success",
      attempt,
      input_tokens: inputTokens,
      cached_input_tokens: cachedInputTokens,
      cache_write_tokens: cacheWriteTokens,
      output_tokens: outputTokens,
      reasoning_tokens: reasoningTokens,
      total_tokens: response.usage?.total_tokens ?? inputTokens + outputTokens,
      estimated_cost_usd: estimatedCostUsd,
      latency_ms: Date.now() - startedAt,
      service_tier: response.service_tier ?? "not_reported",
      pricing_version: process.env.OPENAI_PRICING_VERSION,
    });

    return response.output_text;
  } catch (error) {
    await telemetry.log("llm_request_failed", {
      provider: "openai",
      model,
      feature: "draft_reply",
      team_id: teamId,
      user_id: userId,
      status: "error",
      attempt,
      error_type: error?.constructor?.name ?? "unknown_error",
      latency_ms: Date.now() - startedAt,
    });

    throw error;
  }
}

await telemetry.log("ai_operation_completed", {
  operation_id: operationId,
  response_id: response.id,
  team_id: teamId,
  feature: "draft_reply",
  attempts: attempt,
  outcome: "accepted",
  accepted: true,
});

await telemetry.log("ai_output_reviewed", {
  response_id: responseId,
  team_id: teamId,
  user_id: userId,
  feature: "draft_reply",
  outcome: "accepted",
  accepted: true,
});

SELECT
  date_trunc('day', timestamp_utc) AS day,
  feature,
  model,
  COUNT(*) AS requests,
  SUM(input_tokens) AS input_tokens,
  SUM(cached_input_tokens) AS cached_input_tokens,
  SUM(cache_write_tokens) AS cache_write_tokens,
  SUM(output_tokens) AS output_tokens,
  SUM(reasoning_tokens) AS reasoning_tokens,
  ROUND(SUM(estimated_cost_usd), 4) AS estimated_cost_usd,
  ROUND(AVG(latency_ms), 0) AS avg_latency_ms
FROM llm_request_completed
WHERE timestamp_utc >= now() - INTERVAL '30 days'
GROUP BY day, feature, model
ORDER BY day ASC, estimated_cost_usd DESC;

SELECT
  date_trunc('day', timestamp_utc) AS day,
  model,
  service_tier,
  pricing_version,
  COUNT(*) AS requests,
  ROUND(SUM(estimated_cost_usd), 4) AS estimated_cost_usd
FROM llm_request_completed
WHERE timestamp_utc >= now() - INTERVAL '30 days'
GROUP BY
  date_trunc('day', timestamp_utc),
  model,
  service_tier,
  pricing_version
ORDER BY day ASC, model ASC, service_tier ASC;