promptlayer 1.1.0 → 1.2.0

package/src/run-error-tracking.test.ts

@@ -1,146 +0,0 @@
-import { describe, it, expect, vi, beforeEach, type Mock } from "vitest";
-
-// Mock modules before importing the subject
-vi.mock("@/utils/utils", () => ({
-  trackRequest: vi.fn().mockResolvedValue({ request_id: 1, prompt_blueprint: {} }),
-  configureProviderSettings: vi.fn().mockReturnValue({
-    provider_type: "openai",
-    kwargs: { model: "gpt-4" },
-  }),
-  getProviderConfig: vi.fn().mockReturnValue({
-    function_name: "openai.chat.completions.create",
-    stream_function: null,
-  }),
-  openaiRequest: vi.fn().mockResolvedValue({ choices: [{ message: { content: "hi" } }] }),
-  anthropicRequest: vi.fn(),
-  azureOpenAIRequest: vi.fn(),
-  googleRequest: vi.fn(),
-  mistralRequest: vi.fn(),
-  vertexaiRequest: vi.fn(),
-  amazonBedrockRequest: vi.fn(),
-  anthropicBedrockRequest: vi.fn(),
-  readEnv: vi.fn().mockReturnValue("test-api-key"),
-  runWorkflowRequest: vi.fn(),
-  utilLogRequest: vi.fn(),
-}));
-
-vi.mock("@/templates", () => {
-  return {
-    TemplateManager: class {
-      get = vi.fn().mockResolvedValue({
-        id: 1,
-        version: 1,
-        prompt_template: { type: "chat", messages: [] },
-        metadata: { model: { provider: "openai", name: "gpt-4", parameters: {} } },
-        llm_kwargs: { model: "gpt-4" },
-        custom_provider: null,
-      });
-    },
-  };
-});
-
-vi.mock("@/tracing", () => {
-  const fakeSpan = {
-    setAttribute: vi.fn(),
-    setStatus: vi.fn(),
-    end: vi.fn(),
-    spanContext: () => ({ spanId: "test-span-id" }),
-  };
-  return {
-    getTracer: () => ({
-      startActiveSpan: (_name: string, fn: (span: any) => any) => fn(fakeSpan),
-    }),
-    setupTracing: vi.fn(),
-  };
-});
-
-vi.mock("@/groups", () => ({
-  GroupManager: class {},
-}));
-
-vi.mock("@/track", () => ({
-  TrackManager: class {},
-}));
-
-vi.mock("@/span-wrapper", () => ({
-  wrapWithSpan: vi.fn(),
-}));
-
-vi.mock("@/utils/streaming", () => ({
-  streamResponse: vi.fn().mockReturnValue({ async *[Symbol.asyncIterator]() {} }),
-}));
-
-import { PromptLayer } from "@/index";
-import { trackRequest, openaiRequest } from "@/utils/utils";
-import { RateLimitError } from "openai";
-
-describe("run() error tracking", () => {
-  let client: PromptLayer;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    client = new PromptLayer({ apiKey: "test-api-key" });
-  });
-
-  it("tracks error with UNKNOWN_ERROR type and re-throws when LLM call fails", async () => {
-    const llmError = new Error("model overloaded");
-    (openaiRequest as Mock).mockRejectedValueOnce(llmError);
-
-    await expect(
-      client.run({ promptName: "test-prompt" })
-    ).rejects.toThrow("model overloaded");
-
-    expect(trackRequest).toHaveBeenCalledWith(
-      expect.any(String),
-      expect.objectContaining({
-        request_response: {},
-        status: "ERROR",
-        error_type: "UNKNOWN_ERROR",
-        error_message: "model overloaded",
-      }),
-      true
-    );
-  });
-
-  it("tracks PROVIDER_RATE_LIMIT when LLM throws RateLimitError", async () => {
-    const rateLimitError = new RateLimitError(
-      429, undefined, "Too Many Requests", undefined
-    );
-    (openaiRequest as Mock).mockRejectedValueOnce(rateLimitError);
-
-    await expect(
-      client.run({ promptName: "test-prompt" })
-    ).rejects.toThrow("Too Many Requests");
-
-    expect(trackRequest).toHaveBeenCalledWith(
-      expect.any(String),
-      expect.objectContaining({
-        request_response: {},
-        status: "ERROR",
-        error_type: "PROVIDER_RATE_LIMIT",
-        error_message: expect.stringContaining("Too Many Requests"),
-      }),
-      true
-    );
-  });
-
-  it("calls trackRequest without error fields on success", async () => {
-    const successResponse = { choices: [{ message: { content: "hello" } }] };
-    (openaiRequest as Mock).mockResolvedValueOnce(successResponse);
-
-    await client.run({ promptName: "test-prompt" });
-
-    expect(trackRequest).toHaveBeenCalledWith(
-      expect.any(String),
-      expect.objectContaining({
-        request_response: successResponse,
-      }),
-      true
-    );
-
-    const callArgs = (trackRequest as Mock).mock.calls[0][1];
-    expect(callArgs).not.toHaveProperty("error_type");
-    expect(callArgs).not.toHaveProperty("error_message");
-    expect(callArgs).not.toHaveProperty("status");
-  });
-});

package/src/span-exporter.ts

@@ -1,120 +0,0 @@
-import { fetchWithRetry, getCommonHeaders } from "@/utils/utils";
-import { Attributes, SpanKind, SpanStatusCode } from "@opentelemetry/api";
-import { ExportResultCode } from "@opentelemetry/core";
-import { ReadableSpan, SpanExporter } from "@opentelemetry/sdk-trace-base";
-
-class PromptLayerSpanExporter implements SpanExporter {
-  private apiKey: string;
-  private baseURL: string;
-  private enableTracing: boolean;
-  private url: string;
-
-  constructor(enableTracing: boolean, apiKey: string, baseURL: string) {
-    this.apiKey = apiKey;
-    this.baseURL = baseURL;
-    this.enableTracing = enableTracing;
-    this.url = `${this.baseURL}/spans-bulk`;
-  }
-
-  private attributesToObject(
-    attributes: Attributes | undefined
-  ): Record<string, any> {
-    if (!attributes) return {};
-    return Object.fromEntries(Object.entries(attributes));
-  }
-
-  private spanKindToString(kind: SpanKind): string {
-    const kindMap: Record<SpanKind, string> = {
-      [SpanKind.INTERNAL]: "SpanKind.INTERNAL",
-      [SpanKind.SERVER]: "SpanKind.SERVER",
-      [SpanKind.CLIENT]: "SpanKind.CLIENT",
-      [SpanKind.PRODUCER]: "SpanKind.PRODUCER",
-      [SpanKind.CONSUMER]: "SpanKind.CONSUMER",
-    };
-    return kindMap[kind] || "SpanKind.INTERNAL";
-  }
-
-  private statusCodeToString(code: SpanStatusCode): string {
-    const statusMap: Record<SpanStatusCode, string> = {
-      [SpanStatusCode.ERROR]: "StatusCode.ERROR",
-      [SpanStatusCode.OK]: "StatusCode.OK",
-      [SpanStatusCode.UNSET]: "StatusCode.UNSET",
-    };
-    return statusMap[code] || "StatusCode.UNSET";
-  }
-
-  private toNanoseconds(time: [number, number]): string {
-    return (BigInt(time[0]) * BigInt(1e9) + BigInt(time[1])).toString();
-  }
-
-  export(spans: ReadableSpan[]): Promise<ExportResultCode> {
-    if (!this.enableTracing) {
-      return Promise.resolve(ExportResultCode.SUCCESS);
-    }
-
-    const requestData = spans.map((span) => ({
-      name: span.name,
-      context: {
-        trace_id: span.spanContext().traceId,
-        span_id: span.spanContext().spanId,
-        trace_state: span.spanContext().traceState?.serialize() || "",
-      },
-      kind: this.spanKindToString(span.kind),
-      parent_id: span.parentSpanId || null,
-      start_time: this.toNanoseconds(span.startTime),
-      end_time: this.toNanoseconds(span.endTime),
-      status: {
-        status_code: this.statusCodeToString(span.status.code),
-        description: span.status.message,
-      },
-      attributes: this.attributesToObject(span.attributes),
-      events: span.events.map((event) => ({
-        name: event.name,
-        timestamp: this.toNanoseconds(event.time),
-        attributes: this.attributesToObject(event.attributes),
-      })),
-      links: span.links.map((link) => ({
-        context: link.context,
-        attributes: this.attributesToObject(link.attributes),
-      })),
-      resource: {
-        attributes: {
-          ...span.resource.attributes,
-          "service.name": "prompt-layer-js",
-        },
-        schema_url: "",
-      },
-    }));
-
-    return fetchWithRetry(this.url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "X-API-KEY": this.apiKey || "",
-        ...getCommonHeaders(),
-      },
-      body: JSON.stringify({
-        spans: requestData,
-      }),
-    })
-      .then((response) => {
-        if (!response.ok) {
-          console.error(
-            `Error exporting spans\nHTTP error! status: ${response.status}`
-          );
-          return ExportResultCode.FAILED;
-        }
-        return ExportResultCode.SUCCESS;
-      })
-      .catch((error) => {
-        console.error("Error exporting spans:", error);
-        return ExportResultCode.FAILED;
-      });
-  }
-
-  shutdown(): Promise<void> {
-    return Promise.resolve();
-  }
-}
-
-export default PromptLayerSpanExporter;

package/src/span-wrapper.ts

@@ -1,51 +0,0 @@
-import * as opentelemetry from '@opentelemetry/api';
-import { getTracer } from '@/tracing';
-
-export const wrapWithSpan = (functionName: string, func: Function, attributes?: Record<string, any>) => {
-  return function (...args: any[]) {
-    const tracer = getTracer();
-
-    const wrapperFunction = (span: opentelemetry.Span) => {
-      try {
-        if (attributes) {
-          Object.entries(attributes).forEach(([key, value]) => {
-            span.setAttribute(key, value);
-          });
-        }
-
-        span.setAttribute('function_input', JSON.stringify(args));
-        const result = func(...args);
-
-        if (result instanceof Promise) {
-          return result.then((resolvedResult) => {
-            span.setAttribute('function_output', JSON.stringify(resolvedResult));
-            span.setStatus({ code: opentelemetry.SpanStatusCode.OK });
-            return resolvedResult;
-          }).catch((error) => {
-            handleError(span, error, args);
-            throw error;
-          }).finally(() => span.end());
-        } else {
-          span.setAttribute('function_output', JSON.stringify(result));
-          span.setStatus({ code: opentelemetry.SpanStatusCode.OK });
-          span.end();
-          return result;
-        }
-      } catch (error) {
-        handleError(span, error, args);
-        throw error;
-      }
-    };
-
-    return tracer.startActiveSpan(functionName, wrapperFunction);
-  };
-};
-
-const handleError = (span: opentelemetry.Span, error: any, args: any[]) => {
-  span.setAttribute('function_input', JSON.stringify(args));
-  span.setStatus({
-    code: opentelemetry.SpanStatusCode.ERROR,
-    message: error instanceof Error ? error.message : 'Unknown error',
-  });
-  span.end();
-}

package/src/templates.ts

@@ -1,37 +0,0 @@
-import {
-  GetPromptTemplateParams,
-  Pagination,
-  PublishPromptTemplate,
-} from "@/types";
-import {
-  getAllPromptTemplates,
-  getPromptTemplate,
-  publishPromptTemplate,
-} from "@/utils/utils";
-
-export class TemplateManager {
-  apiKey: string;
-  baseURL: string;
-  throwOnError: boolean;
-
-  constructor(apiKey: string, baseURL: string, throwOnError: boolean = true) {
-    this.apiKey = apiKey;
-    this.baseURL = baseURL;
-    this.throwOnError = throwOnError;
-  }
-
-  get = (promptName: string, params?: Partial<GetPromptTemplateParams>) =>
-    getPromptTemplate(
-      this.apiKey,
-      this.baseURL,
-      promptName,
-      params,
-      this.throwOnError
-    );
-
-  publish = (body: PublishPromptTemplate) =>
-    publishPromptTemplate(this.apiKey, this.baseURL, body, this.throwOnError);
-
-  all = (params?: Pagination) =>
-    getAllPromptTemplates(this.apiKey, this.baseURL, params, this.throwOnError);
-}

package/src/tracing.ts

@@ -1,20 +0,0 @@
-import PromptLayerSpanExporter from "@/span-exporter";
-import * as opentelemetry from "@opentelemetry/api";
-import { SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
-import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
-
-export const getTracer = (name: string = "promptlayer-tracer") => {
-  return opentelemetry.trace.getTracer(name);
-};
-
-export const setupTracing = (
-  enableTracing: boolean,
-  apiKey: string,
-  baseURL: string
-) => {
-  const provider = new NodeTracerProvider();
-  const exporter = new PromptLayerSpanExporter(enableTracing, apiKey, baseURL);
-  const processor = new SimpleSpanProcessor(exporter);
-  provider.addSpanProcessor(processor);
-  provider.register();
-};

package/src/track.ts

@@ -1,84 +0,0 @@
-import { TrackGroup, TrackMetadata, TrackPrompt, TrackScore } from "@/types";
-import {
-  promptLayerTrackGroup,
-  promptLayerTrackMetadata,
-  promptLayerTrackPrompt,
-  promptLayerTrackScore,
-} from "@/utils/utils";
-
-const metadata = (
-  apiKey: string,
-  baseURL: string,
-  body: TrackMetadata,
-  throwOnError: boolean = true
-): Promise<boolean> => {
-  if (!(body.metadata instanceof Object)) {
-    throw new Error("Please provide a dictionary of metadata.");
-  }
-  for (const [key, value] of Object.entries(body.metadata)) {
-    if (typeof key !== "string" || typeof value !== "string") {
-      throw new Error(
-        "Please provide a dictionary of metadata with key value pair of strings."
-      );
-    }
-  }
-  return promptLayerTrackMetadata(apiKey, baseURL, body, throwOnError);
-};
-
-const score = (
-  apiKey: string,
-  baseURL: string,
-  body: TrackScore,
-  throwOnError: boolean = true
-): Promise<boolean> => {
-  if (typeof body.score !== "number") {
-    throw new Error("Score must be a number");
-  }
-  if (body.score < 0 || body.score > 100) {
-    throw new Error("Score must be a number between 0 and 100.");
-  }
-  return promptLayerTrackScore(apiKey, baseURL, body, throwOnError);
-};
-
-const prompt = (
-  apiKey: string,
-  baseURL: string,
-  body: TrackPrompt,
-  throwOnError: boolean = true
-): Promise<boolean> => {
-  if (!(body.prompt_input_variables instanceof Object)) {
-    throw new Error("Prompt template input variable dictionary not provided.");
-  }
-  return promptLayerTrackPrompt(apiKey, baseURL, body, throwOnError);
-};
-
-const group = (
-  apiKey: string,
-  baseURL: string,
-  body: TrackGroup,
-  throwOnError: boolean = true
-) => promptLayerTrackGroup(apiKey, baseURL, body, throwOnError);
-
-export class TrackManager {
-  apiKey: string;
-  baseURL: string;
-  throwOnError: boolean;
-
-  constructor(apiKey: string, baseURL: string, throwOnError: boolean = true) {
-    this.apiKey = apiKey;
-    this.baseURL = baseURL;
-    this.throwOnError = throwOnError;
-  }
-
-  group = (body: TrackGroup) =>
-    group(this.apiKey, this.baseURL, body, this.throwOnError);
-
-  metadata = (body: TrackMetadata) =>
-    metadata(this.apiKey, this.baseURL, body, this.throwOnError);
-
-  prompt = (body: TrackPrompt) =>
-    prompt(this.apiKey, this.baseURL, body, this.throwOnError);
-
-  score = (body: TrackScore) =>
-    score(this.apiKey, this.baseURL, body, this.throwOnError);
-}