@agentuity/core 1.0.32 → 1.0.34

package/src/services/queue/analytics.ts

@@ -0,0 +1,343 @@
+import { z } from 'zod';
+import { type APIClient, APIResponseSchema } from '../api.ts';
+import {
+	type AnalyticsOptions,
+	type OrgAnalytics,
+	OrgAnalyticsSchema,
+	type QueueAnalytics,
+	QueueAnalyticsSchema,
+	type SSEStatsEvent,
+	SSEStatsEventSchema,
+	type StreamAnalyticsOptions,
+	type TimeSeriesData,
+	TimeSeriesDataSchema,
+} from './types.ts';
+import {
+	buildQueueHeaders,
+	QueueError,
+	QueueNotFoundError,
+	queueApiPathWithQuery,
+	withQueueErrorHandling,
+} from './util.ts';
+import { validateQueueName } from './validation.ts';
+
+export const OrgAnalyticsResponseSchema = APIResponseSchema(
+	z.object({ analytics: OrgAnalyticsSchema })
+);
+export const QueueAnalyticsResponseSchema = APIResponseSchema(
+	z.object({ analytics: QueueAnalyticsSchema })
+);
+export const TimeSeriesResponseSchema = APIResponseSchema(
+	z.object({ timeseries: TimeSeriesDataSchema })
+);
+
+/**
+ * Build query string from analytics options.
+ */
+function buildAnalyticsQuery(options?: AnalyticsOptions): string | undefined {
+	if (!options) return undefined;
+
+	const params = new URLSearchParams();
+	if (options.start) params.set('start', options.start);
+	if (options.end) params.set('end', options.end);
+	if (options.granularity) params.set('granularity', options.granularity);
+	if (options.projectId) params.set('project_id', options.projectId);
+	if (options.agentId) params.set('agent_id', options.agentId);
+
+	const query = params.toString();
+	return query || undefined;
+}
+
+/**
+ * Get org-level analytics for all queues.
+ *
+ * Returns aggregated statistics across all queues in the organization.
+ *
+ * @param client - The API client instance
+ * @param options - Analytics options (time range, filters)
+ * @returns Org-level analytics summary
+ * @throws {QueueError} If the API request fails
+ *
+ * @example
+ * ```typescript
+ * const analytics = await getOrgAnalytics(client, {
+ *   start: '2026-01-14T00:00:00Z',
+ *   end: '2026-01-15T00:00:00Z',
+ * });
+ * console.log(`Total queues: ${analytics.summary.total_queues}`);
+ * console.log(`Messages published: ${analytics.summary.total_messages_published}`);
+ * ```
+ */
+export async function getOrgAnalytics(
+	client: APIClient,
+	options?: AnalyticsOptions
+): Promise<OrgAnalytics> {
+	const queryString = buildAnalyticsQuery(options);
+	const url = queueApiPathWithQuery('analytics/org', queryString);
+	const resp = await client.get(
+		url,
+		OrgAnalyticsResponseSchema,
+		undefined,
+		buildQueueHeaders(options?.orgId)
+	);
+
+	if (resp.success) {
+		return resp.data.analytics;
+	}
+
+	throw new QueueError({
+		message: resp.message || 'Failed to get org analytics',
+	});
+}
+
+/**
+ * Get org-level time series analytics.
+ *
+ * Returns published and delivery metrics aggregated across all queues.
+ *
+ * @param client - The API client instance
+ * @param options - Analytics options (time range, filters)
+ * @returns Time series analytics data for the org
+ * @throws {QueueError} If the API request fails
+ */
+export async function getOrgTimeSeries(
+	client: APIClient,
+	options?: AnalyticsOptions
+): Promise<TimeSeriesData> {
+	const queryString = buildAnalyticsQuery(options);
+	const url = queueApiPathWithQuery('analytics/org/timeseries', queryString);
+	const resp = await client.get(
+		url,
+		TimeSeriesResponseSchema,
+		undefined,
+		buildQueueHeaders(options?.orgId)
+	);
+
+	if (resp.success) {
+		return resp.data.timeseries;
+	}
+
+	throw new QueueError({
+		message: resp.message || 'Failed to get org time series',
+	});
+}
+
+/**
+ * Get detailed analytics for a specific queue.
+ *
+ * Returns current state, period statistics, latency metrics, and destination stats.
+ *
+ * @param client - The API client instance
+ * @param name - The queue name
+ * @param options - Analytics options (time range, filters)
+ * @returns Queue analytics
+ * @throws {QueueNotFoundError} If the queue does not exist
+ * @throws {QueueError} If the API request fails
+ *
+ * @example
+ * ```typescript
+ * const analytics = await getQueueAnalytics(client, 'order-processing', {
+ *   start: '2026-01-14T00:00:00Z',
+ * });
+ * console.log(`Backlog: ${analytics.current.backlog}`);
+ * console.log(`P95 latency: ${analytics.latency.p95_ms}ms`);
+ * ```
+ */
+export async function getQueueAnalytics(
+	client: APIClient,
+	name: string,
+	options?: AnalyticsOptions
+): Promise<QueueAnalytics> {
+	validateQueueName(name);
+	const queryString = buildAnalyticsQuery(options);
+	const url = queueApiPathWithQuery('analytics/queue', queryString, name);
+	const resp = await withQueueErrorHandling(
+		() =>
+			client.get(
+				url,
+				QueueAnalyticsResponseSchema,
+				undefined,
+				buildQueueHeaders(options?.orgId)
+			),
+		{ queueName: name }
+	);
+
+	if (resp.success) {
+		return resp.data.analytics;
+	}
+
+	throw new QueueError({
+		queueName: name,
+		message: resp.message || 'Failed to get queue analytics',
+	});
+}
+
+/**
+ * Get time series analytics data for a queue.
+ *
+ * Returns time-bucketed metrics for visualization in charts and graphs.
+ *
+ * @param client - The API client instance
+ * @param name - The queue name
+ * @param options - Analytics options (time range, granularity)
+ * @returns Time series data
+ * @throws {QueueNotFoundError} If the queue does not exist
+ * @throws {QueueError} If the API request fails
+ *
+ * @example
+ * ```typescript
+ * const timeseries = await getQueueTimeSeries(client, 'order-processing', {
+ *   granularity: 'hour',
+ *   start: '2026-01-14T00:00:00Z',
+ * });
+ * for (const point of timeseries.series) {
+ *   console.log(`${point.timestamp}: ${point.throughput} msg/h`);
+ * }
+ * ```
+ */
+export async function getQueueTimeSeries(
+	client: APIClient,
+	name: string,
+	options?: AnalyticsOptions
+): Promise<TimeSeriesData> {
+	validateQueueName(name);
+	const queryString = buildAnalyticsQuery(options);
+	const url = queueApiPathWithQuery('analytics/timeseries', queryString, name);
+	const resp = await withQueueErrorHandling(
+		() => client.get(url, TimeSeriesResponseSchema, undefined, buildQueueHeaders(options?.orgId)),
+		{ queueName: name }
+	);
+
+	if (resp.success) {
+		return resp.data.timeseries;
+	}
+
+	throw new QueueError({
+		queueName: name,
+		message: resp.message || 'Failed to get queue time series',
+	});
+}
+
+/**
+ * Stream real-time analytics for all queues via SSE.
+ *
+ * Returns an async iterator that yields stats events at the specified interval.
+ * The connection stays open until the iterator is closed or an error occurs.
+ *
+ * @param client - The API client instance
+ * @param options - Stream options (interval, orgId)
+ * @returns Async iterator of SSE stats events
+ *
+ * @example
+ * ```typescript
+ * const stream = streamOrgAnalytics(client, { interval: 5 });
+ * for await (const event of stream) {
+ *   console.log(`Backlog: ${event.backlog}, Throughput: ${event.throughput_1m}/min`);
+ * }
+ * ```
+ */
+export async function* streamOrgAnalytics(
+	client: APIClient,
+	options?: StreamAnalyticsOptions
+): AsyncGenerator<SSEStatsEvent, void, unknown> {
+	const params = new URLSearchParams();
+	if (options?.interval) params.set('interval', String(options.interval));
+	const queryString = params.toString() || undefined;
+
+	const url = queueApiPathWithQuery('analytics/stream', queryString);
+
+	yield* streamSSE(client, url, options?.orgId);
+}
+
+/**
+ * Stream real-time analytics for a specific queue via SSE.
+ *
+ * Returns an async iterator that yields stats events at the specified interval.
+ *
+ * @param client - The API client instance
+ * @param name - The queue name
+ * @param options - Stream options (interval, orgId)
+ * @returns Async iterator of SSE stats events
+ *
+ * @example
+ * ```typescript
+ * const stream = streamQueueAnalytics(client, 'order-processing', { interval: 5 });
+ * for await (const event of stream) {
+ *   console.log(`Backlog: ${event.backlog}, In-flight: ${event.messages_in_flight}`);
+ * }
+ * ```
+ */
+export async function* streamQueueAnalytics(
+	client: APIClient,
+	name: string,
+	options?: StreamAnalyticsOptions
+): AsyncGenerator<SSEStatsEvent, void, unknown> {
+	validateQueueName(name);
+
+	const params = new URLSearchParams();
+	if (options?.interval) params.set('interval', String(options.interval));
+	const queryString = params.toString() || undefined;
+
+	const url = queueApiPathWithQuery('analytics/stream', queryString, name);
+
+	yield* streamSSE(client, url, options?.orgId, name);
+}
+
+/**
+ * Internal helper to stream SSE events from a URL.
+ * Uses rawGet for streaming response access.
+ */
+async function* streamSSE(
+	client: APIClient,
+	url: string,
+	orgId?: string,
+	queueName?: string
+): AsyncGenerator<SSEStatsEvent, void, unknown> {
+	const response = await client.rawGet(url, undefined, buildQueueHeaders(orgId));
+
+	if (!response.ok) {
+		if (response.status === 404 && queueName) {
+			throw new QueueNotFoundError({ queueName });
+		}
+		throw new QueueError({
+			message: `SSE connection failed: ${response.status} ${response.statusText}`,
+		});
+	}
+
+	const reader = response.body?.getReader();
+	if (!reader) {
+		throw new QueueError({ message: 'No response body for SSE stream' });
+	}
+
+	const decoder = new TextDecoder();
+	let buffer = '';
+
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split('\n');
+			buffer = lines.pop() || '';
+
+			for (const line of lines) {
+				if (line.startsWith('data: ')) {
+					const jsonStr = line.slice(6).trim();
+					if (jsonStr && jsonStr !== '{}') {
+						try {
+							const parsed = JSON.parse(jsonStr);
+							const event = SSEStatsEventSchema.parse(parsed);
+							yield event;
+						} catch {
+							// Skip malformed events
+						}
+					}
+				}
+			}
+		}
+	} finally {
+		await reader.cancel();
+		reader.releaseLock();
+	}
+}

package/src/services/queue/consumers.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+import { type APIClient, APIResponseSchema } from '../api.ts';
+import { type Consumer, ConsumerSchema, type QueueApiOptions } from './types.ts';
+import { buildQueueHeaders, QueueError, queueApiPath, withQueueErrorHandling } from './util.ts';
+import { validateQueueName } from './validation.ts';
+
+export const ConsumersListResponseSchema = APIResponseSchema(
+	z.object({
+		consumers: z.array(ConsumerSchema),
+		total: z.number(),
+	})
+);
+
+/**
+ * List consumers for a queue.
+ *
+ * Returns active WebSocket consumers and recently disconnected durable consumers.
+ *
+ * @param client - The API client instance
+ * @param queueName - The name of the queue
+ * @param options - Optional API options (e.g., orgId for CLI-authenticated requests)
+ * @returns Array of consumers
+ * @throws {QueueNotFoundError} If the queue does not exist
+ * @throws {QueueError} If the API request fails
+ *
+ * @example
+ * ```typescript
+ * const consumers = await listConsumers(client, 'order-processing');
+ * for (const consumer of consumers) {
+ *   const status = consumer.disconnected_at ? 'disconnected' : 'connected';
+ *   console.log(`Consumer ${consumer.id}: ${status} (durable: ${consumer.durable})`);
+ * }
+ * ```
+ */
+export async function listConsumers(
+	client: APIClient,
+	queueName: string,
+	options?: QueueApiOptions
+): Promise<Consumer[]> {
+	validateQueueName(queueName);
+	const url = queueApiPath('consumers/list', queueName);
+	const resp = await withQueueErrorHandling(
+		() =>
+			client.get(url, ConsumersListResponseSchema, undefined, buildQueueHeaders(options?.orgId)),
+		{ queueName }
+	);
+
+	if (resp.success) {
+		return resp.data.consumers;
+	}
+
+	throw new QueueError({
+		queueName,
+		message: resp.message || 'Failed to list consumers',
+	});
+}