@erickluis00/otelviewer/dist/middleware.d.ts

Shared OpenTelemetry tracing utilities, types, and batch processor for Realtime OpenTelemetry Viewer [WIP]

interface MiddlewareConfig {
    appName?: string;
    skipPaths?: string[];
    captureRequestBody?: boolean;
    captureResponseBody?: boolean;
    maxBodySize?: number;
}
/**
 * Express middleware factory for OpenTelemetry tracing
 *
 * @example
 * ```typescript
 * import express from 'express'
 * import { createExpressMiddleware } from '@erickluis00/otelviewer-shared'
 *
 * const app = express()
 *
 * // Use the middleware
 * app.use(createExpressMiddleware({
 *   appName: 'my-express-api',
 *   skipPaths: ['/health']
 * }))
 *
 * app.get('/users', (req, res) => {
 *   res.json({ users: [] })
 * })
 * ```
 */
export declare function createExpressMiddleware(config?: MiddlewareConfig): (req: any, res: any, next: any) => any;
/**
 * Hono middleware factory for OpenTelemetry tracing
 *
 * @example
 * ```typescript
 * import { Hono } from 'hono'
 * import { createHonoMiddleware } from '@erickluis00/otelviewer-shared'
 *
 * const app = new Hono()
 *
 * // Use the middleware
 * app.use('*', createHonoMiddleware({
 *   appName: 'my-hono-api',
 *   skipPaths: ['/health']
 * }))
 *
 * app.get('/users', (c) => c.json({ users: [] }))
 * ```
 */
export declare function createHonoMiddleware(config?: MiddlewareConfig): (c: any, next: any) => Promise<void>;
/**
 * TRPC middleware factory for OpenTelemetry tracing
 *
 * @example
 * ```typescript
 * import { initTRPC } from '@trpc/server'
 * import { createTRPCMiddleware } from '@erickluis00/otelviewer-shared'
 *
 * const t = initTRPC.create()
 *
 * // Create the middleware
 * const tracingMiddleware = t.middleware(createTRPCMiddleware({
 *   appName: 'my-trpc-api'
 * }))
 *
 * // Use in procedures
 * const publicProcedure = t.procedure.use(tracingMiddleware)
 *
 * export const appRouter = t.router({
 *   getUsers: publicProcedure.query(async () => {
 *     return { users: [] }
 *   }),
 *   createUser: publicProcedure
 *     .input(z.object({ name: z.string() }))
 *     .mutation(async ({ input }) => {
 *       return { user: input }
 *     })
 * })
 * ```
 */
export declare function createTRPCMiddleware(config?: MiddlewareConfig): (opts: any) => Promise<any>;
/**
 * Next.js API handler wrapper for OpenTelemetry tracing
 *
 * @example
 * ```typescript
 * import { createNextJSWrapper } from '@erickluis00/otelviewer-shared'
 * import { appRouter } from '@/trpc/server/router'
 * import { createNextApiHandler, NextApiRequest, NextApiResponse } from '@trpc/server/adapters/next'
 * import { createTRPCContext } from '@/trpc/server/procedures'
 *
 * const nextApiHandler = createNextApiHandler({
 *     router: appRouter,
 *     createContext: createTRPCContext,
 * })
 *
 * // Wrap with tracing
 * export default createNextJSWrapper({
 *   appName: 'my-nextjs-api',
 *   skipPaths: ['/health']
 * })(nextApiHandler)
 * ```
 */
export declare function createNextJSWrapper(config?: MiddlewareConfig): <T = any, U = any>(handler: (req: T, res: U) => Promise<void> | void) => (req: any, res: any) => Promise<void>;
/**
 * Simple function to create a request ID
 */
export declare function generateRequestId(): string;
/**
 * Helper function to check if a request should be traced
 */
export declare function shouldTrace(path: string, skipPaths: string[]): boolean;
/**
 * Helper to format duration
 */
export declare function formatDuration(ms: number): string;
export {};
//# sourceMappingURL=middleware.d.ts.map