로그 기록하기

import { Naite } from "sonamu";

// 기본 사용
Naite.t("user:create", { userId: 123, username: "john" });

test("주문 처리 전체 흐름", async () => {
  const orderId = 123;
  
  // 1단계: 주문 검증
  Naite.t("order:validate:start", { orderId });
  await validateOrder(orderId);
  Naite.t("order:validate:done", { valid: true });
  
  // 2단계: 재고 확인
  Naite.t("order:inventory:check", { orderId });
  const available = await checkInventory(orderId);
  Naite.t("order:inventory:result", { available });
  
  // 3단계: 결제 처리
  Naite.t("order:payment:start", { orderId });
  await processPayment(orderId);
  Naite.t("order:payment:done", { transactionId: "tx_123" });
  
  // 4단계: 배송 시작
  Naite.t("order:shipping:start", { orderId });
  await startShipping(orderId);
  Naite.t("order:shipping:done", { trackingNumber: "TRK_001" });
});

t(name: string, value: any) {
  // 테스트 환경이 아니면 즉시 종료
  if (process.env.NODE_ENV !== "test") {
    return;
  }
  // ...
}

try {
  const context = Sonamu.getContext();
  const store = context?.naiteStore;
  
  if (!store) {
    return; // Context 없으면 무시
  }
  // ...
} catch {
  // Context 없는 상황
}

// 콜스택 수집
const stack = extractCallStack();

function extractCallStack(): StackFrame[] {
  const stack = new Error().stack;
  
  // "Error", "extractCallStack", "Naite.t" 제외
  const frames = stack.split("\n")
    .slice(3)
    .map(parseStackFrame)
    .filter(frame => frame !== null);
  
  // runWithContext 발견 시 종료
  const contextIndex = frames.findIndex(
    f => f.functionName?.includes("runWithContext")
  );
  
  return contextIndex >= 0 
    ? frames.slice(0, contextIndex + 1) 
    : frames;
}

const trace: NaiteTrace = {
  key: name,
  data: value,
  stack: stack,
  at: new Date(),
};

// Store에 추가 (항상 배열로 관리)
const existing = store.get(name) ?? [];
store.set(name, [...existing, trace]);

async function processPayment(order: Order) {
  Naite.t("payment:start", { 
    orderId: order.id,
    method: order.payment_method 
  });
  
  if (order.payment_method === "card") {
    Naite.t("payment:card:selected", { cardNumber: "****1234" });
    await chargeCard(order);
    Naite.t("payment:card:success", { transactionId: "tx_123" });
  } else if (order.payment_method === "bank") {
    Naite.t("payment:bank:selected", { bankCode: "001" });
    await transferBank(order);
    Naite.t("payment:bank:success", { transferId: "tf_456" });
  }
  
  Naite.t("payment:done", { orderId: order.id });
}

test("카드 결제", async () => {
  const order = { id: 1, payment_method: "card" };
  await processPayment(order);
  
  // 카드 결제 경로가 실행되었는지 확인
  const cardLogs = Naite.get("payment:card:*").result();
  expect(cardLogs.length).toBeGreaterThan(0);
  
  // 계좌 이체는 실행 안 됨
  const bankLogs = Naite.get("payment:bank:*").result();
  expect(bankLogs).toHaveLength(0);
});

async function createUser(data: UserCreateInput) {
  Naite.t("user:create:input", data);
  
  try {
    // 유효성 검사
    await validateUser(data);
    Naite.t("user:create:validation:pass", {});
    
    // DB 저장
    const user = await db.insert("users").values(data);
    Naite.t("user:create:success", { userId: user.id });
    
    return user;
  } catch (error) {
    // 에러 상세 기록
    Naite.t("user:create:error", {
      errorType: error.constructor.name,
      errorMessage: error.message,
      errorCode: error.code,
      inputData: data,
      stack: error.stack,
    });
    throw error;
  }
}

test("잘못된 입력 처리", async () => {
  try {
    await createUser({ username: "" }); // 빈 값
    throw new Error("Should have failed");
  } catch (error) {
    // 에러 로그 확인
    const errorLog = Naite.get("user:create:error").first();
    
    expect(errorLog).toBeDefined();
    expect(errorLog.errorType).toBe("ValidationError");
    expect(errorLog.errorMessage).toContain("username");
    
    // 유효성 검사를 통과하지 못했는지 확인
    const validationPass = Naite.get("user:create:validation:pass").result();
    expect(validationPass).toHaveLength(0);
  }
});

test("데이터 처리 성능", async () => {
  Naite.t("process:start", { timestamp: Date.now() });
  
  // 단계 1: 데이터 조회
  Naite.t("process:fetch:start", { timestamp: Date.now() });
  const data = await fetchLargeData();
  Naite.t("process:fetch:done", { 
    timestamp: Date.now(),
    dataSize: data.length 
  });
  
  // 단계 2: 데이터 처리
  Naite.t("process:transform:start", { timestamp: Date.now() });
  const processed = await transformData(data);
  Naite.t("process:transform:done", { 
    timestamp: Date.now(),
    processedCount: processed.length 
  });
  
  // 단계 3: DB 저장
  Naite.t("process:save:start", { timestamp: Date.now() });
  await saveToDatabase(processed);
  Naite.t("process:save:done", { timestamp: Date.now() });
  
  Naite.t("process:end", { timestamp: Date.now() });
  
  // 각 단계별 소요 시간 계산
  const logs = Naite.get("process:*").result();
  const start = logs.find(l => l.timestamp).timestamp;
  const fetchDone = logs.find(l => l.timestamp && l.dataSize).timestamp;
  const transformDone = logs.find(l => l.timestamp && l.processedCount).timestamp;
  const saveDone = logs[logs.length - 2].timestamp;
  
  console.log(`Fetch: ${fetchDone - start}ms`);
  console.log(`Transform: ${transformDone - fetchDone}ms`);
  console.log(`Save: ${saveDone - transformDone}ms`);
});

// ✅ 모든 타입 가능
Naite.t("key", "string");
Naite.t("key", 123);
Naite.t("key", true);
Naite.t("key", { nested: { object: true } });
Naite.t("key", [1, 2, 3]);
Naite.t("key", new Date());
Naite.t("key", null);
Naite.t("key", undefined);

if (process.env.NODE_ENV !== "test") {
  return; // 즉시 종료, 비용 없음
}

const DEBUG = process.env.DEBUG_NAITE === "true";

function processItem(item: any) {
  if (DEBUG) {
    Naite.t("process:detail", item);
  }
  
  // 처리 로직
}

// 사용:
// DEBUG_NAITE=true pnpm test