telnyx 7.22.0 → 7.24.0

package/src/resources/compute/funcs/export.ts

@@ -0,0 +1,156 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../core/resource';
+import { APIPromise } from '../../../core/api-promise';
+import { buildHeaders } from '../../../internal/headers';
+import { RequestOptions } from '../../../internal/request-options';
+import { path } from '../../../internal/utils/path';
+
+export class Export extends APIResource {
+  /**
+   * Stops exporting a function's logs and removes its destination configuration.
+   * Idempotent: deleting when nothing is configured succeeds.
+   *
+   * @example
+   * ```ts
+   * await client.compute.funcs.export.deleteAll('id');
+   * ```
+   */
+  deleteAll(id: string, options?: RequestOptions): APIPromise<void> {
+    return this._client.delete(path`/compute/funcs/${id}/logs/export`, {
+      ...options,
+      headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
+    });
+  }
+
+  /**
+   * Returns the function's configured log export destination and which log types are
+   * exported. Headers are never returned. Returns 404 (error code 10005) when no
+   * destination is configured for the function.
+   *
+   * @example
+   * ```ts
+   * const funcLogExportConfigResponse =
+   *   await client.compute.funcs.export.list('id');
+   * ```
+   */
+  list(id: string, options?: RequestOptions): APIPromise<FuncLogExportConfigResponse> {
+    return this._client.get(path`/compute/funcs/${id}/logs/export`, options);
+  }
+
+  /**
+   * Configures the external OTLP endpoint a function's runtime and/or invocation
+   * logs are pushed to as they happen. This operation is a **full replace, not a
+   * patch**: `endpoint`, `headers`, `runtime_export_enabled`, and
+   * `invocation_export_enabled` are all required on every call — omitting any of
+   * them is a 422, not "keep the current value". Headers are encrypted at rest and
+   * never returned in any response.
+   *
+   * The endpoint must be an HTTPS URL. When export is configured, new log records
+   * are converted to OTLP log records and delivered continuously; export never
+   * bypasses platform log storage, and delivery retries with a bounded policy while
+   * the destination is unreachable. Only logs generated after configuration are
+   * exported — there is no historical replay.
+   *
+   * @example
+   * ```ts
+   * const funcLogExportConfigResponse =
+   *   await client.compute.funcs.export.create('id', {
+   *     endpoint: 'https://api.honeycomb.io/v1/logs',
+   *     headers: { 'x-honeycomb-team': 'abc123' },
+   *     invocation_export_enabled: true,
+   *     runtime_export_enabled: true,
+   *   });
+   * ```
+   */
+  create(
+    id: string,
+    body: ExportCreateParams,
+    options?: RequestOptions,
+  ): APIPromise<FuncLogExportConfigResponse> {
+    return this._client.put(path`/compute/funcs/${id}/logs/export`, { body, ...options });
+  }
+}
+
+export interface FuncLogExportConfigResponse {
+  /**
+   * Metadata-only view of a function's log export destination. Header values are
+   * write-only (encrypted server-side) and never appear in any response.
+   */
+  data?: FuncLogExportConfigResponse.Data;
+}
+
+export namespace FuncLogExportConfigResponse {
+  /**
+   * Metadata-only view of a function's log export destination. Header values are
+   * write-only (encrypted server-side) and never appear in any response.
+   */
+  export interface Data {
+    /**
+     * Configuration record ID
+     */
+    id?: string;
+
+    created_at?: string;
+
+    /**
+     * Whether export is enabled for this function
+     */
+    enabled?: boolean;
+
+    /**
+     * HTTPS OTLP endpoint URL logs are pushed to
+     */
+    endpoint?: string;
+
+    /**
+     * Function ID this configuration belongs to
+     */
+    func_id?: string;
+
+    /**
+     * Whether invocation records (one per HTTP request) are exported
+     */
+    invocation_export_enabled?: boolean;
+
+    record_type?: 'compute_func_log_export_config';
+
+    /**
+     * Whether runtime logs (function stdout/stderr) are exported
+     */
+    runtime_export_enabled?: boolean;
+
+    updated_at?: string;
+  }
+}
+
+export interface ExportCreateParams {
+  /**
+   * HTTPS URL to push logs to
+   */
+  endpoint: string;
+
+  /**
+   * Headers attached to every export push, as key-value pairs (e.g. an auth token
+   * the collector expects). Required even when empty — {} means "no headers".
+   * Encrypted at rest; never returned.
+   */
+  headers: { [key: string]: string };
+
+  /**
+   * Export invocation records (one per HTTP request) to this destination
+   */
+  invocation_export_enabled: boolean;
+
+  /**
+   * Export runtime logs (function stdout/stderr) to this destination
+   */
+  runtime_export_enabled: boolean;
+}
+
+export declare namespace Export {
+  export {
+    type FuncLogExportConfigResponse as FuncLogExportConfigResponse,
+    type ExportCreateParams as ExportCreateParams,
+  };
+}

package/src/resources/compute/funcs/funcs.ts

@@ -0,0 +1,341 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../core/resource';
+import * as FuncsAPI from './funcs';
+import * as ExportAPI from './export';
+import { Export, ExportCreateParams, FuncLogExportConfigResponse } from './export';
+import { APIPromise } from '../../../core/api-promise';
+import { RequestOptions } from '../../../internal/request-options';
+import { path } from '../../../internal/utils/path';
+
+export class Funcs extends APIResource {
+  export: ExportAPI.Export = new ExportAPI.Export(this._client);
+
+  /**
+   * Returns logs oldest first. `type=runtime` (default) returns function
+   * stdout/stderr. `type=invocations` returns one platform-generated record per HTTP
+   * request served.
+   *
+   * @example
+   * ```ts
+   * const response = await client.compute.funcs.retrieveLogs(
+   *   'id',
+   * );
+   * ```
+   */
+  retrieveLogs(
+    id: string,
+    query: FuncRetrieveLogsParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<FuncRetrieveLogsResponse> {
+    return this._client.get(path`/compute/funcs/${id}/logs`, { query, ...options });
+  }
+
+  /**
+   * Returns aggregate request, latency, CPU, memory, and resource-limit metrics for
+   * a function over the requested window.
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.compute.funcs.retrieveMetricAggregates(
+   *     'id',
+   *     {
+   *       end_time: '2019-12-27T18:11:19.117Z',
+   *       start_time: '2019-12-27T18:11:19.117Z',
+   *     },
+   *   );
+   * ```
+   */
+  retrieveMetricAggregates(
+    id: string,
+    query: FuncRetrieveMetricAggregatesParams,
+    options?: RequestOptions,
+  ): APIPromise<FuncRetrieveMetricAggregatesResponse> {
+    return this._client.get(path`/compute/funcs/${id}/metric_aggregates`, { query, ...options });
+  }
+
+  /**
+   * Lists a function's ship history newest first, including per-ship failure stage
+   * and reason when recorded.
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.compute.funcs.retrieveRevisions('id');
+   * ```
+   */
+  retrieveRevisions(
+    id: string,
+    query: FuncRetrieveRevisionsParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<FuncRetrieveRevisionsResponse> {
+    return this._client.get(path`/compute/funcs/${id}/revisions`, { query, ...options });
+  }
+
+  /**
+   * Returns the latest ship outcome. The stage is `none` on success, `pending` while
+   * building, or a failure stage such as `build`, `platform`, `pre_build`, `deploy`,
+   * or `security_review`. This stage-neutral customer-facing path is an alias over
+   * the same inspection resource as `build_log_inspection`.
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.compute.funcs.retrieveShipInspection('id');
+   * ```
+   */
+  retrieveShipInspection(
+    id: string,
+    options?: RequestOptions,
+  ): APIPromise<FuncRetrieveShipInspectionResponse> {
+    return this._client.get(path`/compute/funcs/${id}/ship_inspection`, options);
+  }
+}
+
+export interface FunctionsObservabilityPaginationMeta {
+  page_number?: number;
+
+  page_size?: number;
+
+  total_pages?: number;
+
+  total_results?: number;
+}
+
+export interface LogsMeta {
+  has_more?: boolean;
+
+  partial?: boolean;
+}
+
+export type FuncRetrieveLogsResponse =
+  | FuncRetrieveLogsResponse.FuncRuntimeLogsResponse
+  | FuncRetrieveLogsResponse.FuncInvocationLogsResponse;
+
+export namespace FuncRetrieveLogsResponse {
+  export interface FuncRuntimeLogsResponse {
+    data?: Array<FuncRuntimeLogsResponse.Data>;
+
+    meta?: FuncsAPI.LogsMeta;
+  }
+
+  export namespace FuncRuntimeLogsResponse {
+    export interface Data {
+      level?: string;
+
+      message?: string;
+
+      record_type?: 'compute_func_runtime_log';
+
+      timestamp?: string;
+    }
+  }
+
+  export interface FuncInvocationLogsResponse {
+    data?: Array<FuncInvocationLogsResponse.Data>;
+
+    meta?: FuncsAPI.LogsMeta;
+  }
+
+  export namespace FuncInvocationLogsResponse {
+    export interface Data {
+      duration_ms?: number;
+
+      method?: string;
+
+      path?: string;
+
+      record_type?: 'compute_func_invocation_log';
+
+      region?: string;
+
+      request_size_bytes?: number;
+
+      response_size_bytes?: number;
+
+      status_code?: number;
+
+      timestamp?: string;
+    }
+  }
+}
+
+export interface FuncRetrieveMetricAggregatesResponse {
+  data?: Array<FuncRetrieveMetricAggregatesResponse.Data>;
+
+  meta?: FunctionsObservabilityPaginationMeta;
+}
+
+export namespace FuncRetrieveMetricAggregatesResponse {
+  export interface Data {
+    cpu_used_cores_avg?: number | null;
+
+    cpu_used_cores_max?: number | null;
+
+    end_time?: string;
+
+    function_id?: string;
+
+    function_name?: string;
+
+    memory_used_bytes_avg?: number | null;
+
+    memory_used_bytes_max?: number | null;
+
+    product?: string;
+
+    record_type?: string;
+
+    request_client_error_rate?: number | null;
+
+    request_count?: number | null;
+
+    request_error_rate?: number | null;
+
+    request_latency_avg_ms?: number | null;
+
+    request_latency_p50_ms?: number | null;
+
+    request_latency_p95_ms?: number | null;
+
+    request_latency_p99_ms?: number | null;
+
+    request_success_rate?: number | null;
+
+    start_time?: string;
+  }
+}
+
+export interface FuncRetrieveRevisionsResponse {
+  data?: Array<FuncRetrieveRevisionsResponse.Data>;
+
+  meta?: FunctionsObservabilityPaginationMeta;
+}
+
+export namespace FuncRetrieveRevisionsResponse {
+  export interface Data {
+    active?: boolean;
+
+    build_ok_at?: string;
+
+    build_status?: string;
+
+    commit_sha?: string;
+
+    deploy_status?: string;
+
+    failure_reason?: string;
+
+    failure_stage?: string;
+
+    image?: string;
+
+    record_type?: string;
+
+    revision_id?: string;
+
+    shipped_at?: string;
+
+    shipped_by?: string;
+  }
+}
+
+export interface FuncRetrieveShipInspectionResponse {
+  data?: FuncRetrieveShipInspectionResponse.Data;
+}
+
+export namespace FuncRetrieveShipInspectionResponse {
+  export interface Data {
+    created_at?: string;
+
+    reason?: string;
+
+    /**
+     * Stable record type retained by both inspection path aliases.
+     */
+    record_type?: 'build_log_inspection';
+
+    runtime?: string;
+
+    snippet?: string;
+
+    stage?: 'build' | 'platform' | 'pre_build' | 'deploy' | 'security_review' | 'none' | 'pending';
+  }
+}
+
+export interface FuncRetrieveLogsParams {
+  /**
+   * Return records at or before this RFC 3339 timestamp.
+   */
+  end_time?: string;
+
+  /**
+   * Maximum records to return.
+   */
+  limit?: number;
+
+  /**
+   * Return records at or after this RFC 3339 timestamp.
+   */
+  start_time?: string;
+
+  /**
+   * Log stream to return.
+   */
+  type?: 'runtime' | 'invocations';
+}
+
+export interface FuncRetrieveMetricAggregatesParams {
+  /**
+   * Exclusive window end, UTC ISO 8601 with milliseconds
+   */
+  end_time: string;
+
+  /**
+   * Inclusive window start, UTC ISO 8601 with milliseconds
+   */
+  start_time: string;
+
+  /**
+   * Edge site filter
+   */
+  'filter[edge_site]'?: string;
+
+  /**
+   * Kubernetes namespace filter
+   */
+  'filter[namespace]'?: string;
+
+  'page[number]'?: number;
+
+  'page[size]'?: number;
+}
+
+export interface FuncRetrieveRevisionsParams {
+  'page[number]'?: number;
+
+  'page[size]'?: number;
+}
+
+Funcs.Export = Export;
+
+export declare namespace Funcs {
+  export {
+    type FunctionsObservabilityPaginationMeta as FunctionsObservabilityPaginationMeta,
+    type LogsMeta as LogsMeta,
+    type FuncRetrieveLogsResponse as FuncRetrieveLogsResponse,
+    type FuncRetrieveMetricAggregatesResponse as FuncRetrieveMetricAggregatesResponse,
+    type FuncRetrieveRevisionsResponse as FuncRetrieveRevisionsResponse,
+    type FuncRetrieveShipInspectionResponse as FuncRetrieveShipInspectionResponse,
+    type FuncRetrieveLogsParams as FuncRetrieveLogsParams,
+    type FuncRetrieveMetricAggregatesParams as FuncRetrieveMetricAggregatesParams,
+    type FuncRetrieveRevisionsParams as FuncRetrieveRevisionsParams,
+  };
+
+  export {
+    Export as Export,
+    type FuncLogExportConfigResponse as FuncLogExportConfigResponse,
+    type ExportCreateParams as ExportCreateParams,
+  };
+}

package/src/resources/compute/funcs/index.ts

@@ -0,0 +1,15 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export { Export, type FuncLogExportConfigResponse, type ExportCreateParams } from './export';
+export {
+  Funcs,
+  type FunctionsObservabilityPaginationMeta,
+  type LogsMeta,
+  type FuncRetrieveLogsResponse,
+  type FuncRetrieveMetricAggregatesResponse,
+  type FuncRetrieveRevisionsResponse,
+  type FuncRetrieveShipInspectionResponse,
+  type FuncRetrieveLogsParams,
+  type FuncRetrieveMetricAggregatesParams,
+  type FuncRetrieveRevisionsParams,
+} from './funcs';