@tracelens/shared 0.1.0

package/dist/schemas/performance.schema.js

@@ -0,0 +1,200 @@
+// Performance timing event schema for TraceLens
+export const PerformanceEventSchema = {
+    type: 'object',
+    required: ['id', 'timestamp', 'type', 'data', 'url', 'userAgent'],
+    properties: {
+        id: {
+            type: 'string',
+            pattern: '^[a-zA-Z0-9_-]+$',
+            minLength: 1,
+            maxLength: 100
+        },
+        timestamp: {
+            type: 'number',
+            minimum: 1577836800000, // 2020-01-01
+            maximum: 2524608000000 // 2050-01-01
+        },
+        type: {
+            type: 'string',
+            enum: ['web-vitals', 'resource-timing', 'navigation-timing', 'long-task']
+        },
+        data: {
+            oneOf: [
+                { $ref: '#/definitions/WebVitalsData' },
+                { $ref: '#/definitions/ResourceTimingData' },
+                { $ref: '#/definitions/NavigationTimingData' },
+                { $ref: '#/definitions/LongTaskData' }
+            ]
+        },
+        url: {
+            type: 'string',
+            format: 'uri',
+            maxLength: 2048
+        },
+        userAgent: {
+            type: 'string',
+            maxLength: 512
+        }
+    },
+    definitions: {
+        WebVitalsData: {
+            type: 'object',
+            properties: {
+                cls: { $ref: '#/definitions/CLSMetric' },
+                fid: { $ref: '#/definitions/FIDMetric' },
+                lcp: { $ref: '#/definitions/LCPMetric' },
+                fcp: { $ref: '#/definitions/FCPMetric' },
+                ttfb: { $ref: '#/definitions/TTFBMetric' },
+                inp: { $ref: '#/definitions/INPMetric' }
+            }
+        },
+        BaseMetric: {
+            type: 'object',
+            required: ['name', 'value', 'rating', 'delta', 'id', 'navigationType'],
+            properties: {
+                name: { type: 'string' },
+                value: { type: 'number', minimum: 0 },
+                rating: {
+                    type: 'string',
+                    enum: ['good', 'needs-improvement', 'poor']
+                },
+                delta: { type: 'number' },
+                id: { type: 'string' },
+                navigationType: {
+                    type: 'string',
+                    enum: ['navigate', 'reload', 'back-forward', 'prerender']
+                }
+            }
+        },
+        CLSMetric: {
+            allOf: [
+                { $ref: '#/definitions/BaseMetric' },
+                {
+                    properties: {
+                        name: { const: 'CLS' },
+                        value: { maximum: 1 }
+                    }
+                }
+            ]
+        },
+        FIDMetric: {
+            allOf: [
+                { $ref: '#/definitions/BaseMetric' },
+                {
+                    properties: {
+                        name: { const: 'FID' },
+                        value: { maximum: 10000 }
+                    }
+                }
+            ]
+        },
+        LCPMetric: {
+            allOf: [
+                { $ref: '#/definitions/BaseMetric' },
+                {
+                    properties: {
+                        name: { const: 'LCP' },
+                        value: { maximum: 30000 }
+                    }
+                }
+            ]
+        },
+        FCPMetric: {
+            allOf: [
+                { $ref: '#/definitions/BaseMetric' },
+                {
+                    properties: {
+                        name: { const: 'FCP' },
+                        value: { maximum: 10000 }
+                    }
+                }
+            ]
+        },
+        TTFBMetric: {
+            allOf: [
+                { $ref: '#/definitions/BaseMetric' },
+                {
+                    properties: {
+                        name: { const: 'TTFB' },
+                        value: { maximum: 5000 }
+                    }
+                }
+            ]
+        },
+        INPMetric: {
+            allOf: [
+                { $ref: '#/definitions/BaseMetric' },
+                {
+                    properties: {
+                        name: { const: 'INP' },
+                        value: { maximum: 1000 }
+                    }
+                }
+            ]
+        },
+        ResourceTimingData: {
+            type: 'object',
+            required: ['name', 'entryType', 'startTime', 'duration'],
+            properties: {
+                name: { type: 'string', maxLength: 2048 },
+                entryType: { const: 'resource' },
+                startTime: { type: 'number', minimum: 0 },
+                duration: { type: 'number', minimum: 0 },
+                initiatorType: { type: 'string' },
+                nextHopProtocol: { type: 'string' },
+                renderBlockingStatus: { type: 'string' },
+                responseStatus: { type: 'number', minimum: 100, maximum: 599 },
+                transferSize: { type: 'number', minimum: 0 },
+                encodedBodySize: { type: 'number', minimum: 0 },
+                decodedBodySize: { type: 'number', minimum: 0 },
+                responseStart: { type: 'number', minimum: 0 },
+                responseEnd: { type: 'number', minimum: 0 }
+            }
+        },
+        NavigationTimingData: {
+            type: 'object',
+            required: ['type'],
+            properties: {
+                domComplete: { type: 'number', minimum: 0 },
+                domContentLoadedEventEnd: { type: 'number', minimum: 0 },
+                domContentLoadedEventStart: { type: 'number', minimum: 0 },
+                domInteractive: { type: 'number', minimum: 0 },
+                loadEventEnd: { type: 'number', minimum: 0 },
+                loadEventStart: { type: 'number', minimum: 0 },
+                redirectCount: { type: 'number', minimum: 0 },
+                type: {
+                    type: 'string',
+                    enum: ['navigate', 'reload', 'back-forward', 'prerender']
+                },
+                unloadEventEnd: { type: 'number', minimum: 0 },
+                unloadEventStart: { type: 'number', minimum: 0 }
+            }
+        },
+        LongTaskData: {
+            type: 'object',
+            required: ['name', 'entryType', 'startTime', 'duration'],
+            properties: {
+                name: { const: 'longtask' },
+                entryType: { const: 'longtask' },
+                startTime: { type: 'number', minimum: 0 },
+                duration: { type: 'number', minimum: 50 }, // Long tasks are >= 50ms
+                attribution: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string' },
+                            entryType: { const: 'taskattribution' },
+                            startTime: { type: 'number', minimum: 0 },
+                            duration: { type: 'number', minimum: 0 },
+                            containerType: { type: 'string' },
+                            containerSrc: { type: 'string' },
+                            containerId: { type: 'string' },
+                            containerName: { type: 'string' }
+                        }
+                    }
+                }
+            }
+        }
+    }
+};

package/dist/schemas/trace.schema.d.ts

@@ -0,0 +1,325 @@
+export declare const TraceSpanSchema: {
+    readonly type: "object";
+    readonly required: readonly ["traceId", "spanId", "operationName", "startTime", "tags", "status"];
+    readonly properties: {
+        readonly traceId: {
+            readonly type: "string";
+            readonly pattern: "^[a-f0-9]{32}$";
+            readonly description: "Hexadecimal trace ID (32 characters)";
+        };
+        readonly spanId: {
+            readonly type: "string";
+            readonly pattern: "^[a-f0-9]{16}$";
+            readonly description: "Hexadecimal span ID (16 characters)";
+        };
+        readonly parentSpanId: {
+            readonly type: "string";
+            readonly pattern: "^[a-f0-9]{16}$";
+            readonly description: "Hexadecimal parent span ID (16 characters)";
+        };
+        readonly operationName: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 256;
+            readonly description: "Name of the operation being traced";
+        };
+        readonly startTime: {
+            readonly type: "number";
+            readonly minimum: 0;
+            readonly description: "Start time in microseconds since epoch";
+        };
+        readonly endTime: {
+            readonly type: "number";
+            readonly minimum: 0;
+            readonly description: "End time in microseconds since epoch";
+        };
+        readonly duration: {
+            readonly type: "number";
+            readonly minimum: 0;
+            readonly description: "Duration in microseconds";
+        };
+        readonly tags: {
+            readonly type: "object";
+            readonly patternProperties: {
+                readonly '^[a-zA-Z][a-zA-Z0-9._-]*$': {
+                    readonly oneOf: readonly [{
+                        readonly type: "string";
+                        readonly maxLength: 1024;
+                    }, {
+                        readonly type: "number";
+                    }, {
+                        readonly type: "boolean";
+                    }];
+                };
+            };
+            readonly additionalProperties: false;
+            readonly description: "Key-value pairs providing additional context";
+        };
+        readonly logs: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly required: readonly ["timestamp", "fields"];
+                readonly properties: {
+                    readonly timestamp: {
+                        readonly type: "number";
+                        readonly minimum: 0;
+                        readonly description: "Log timestamp in microseconds since epoch";
+                    };
+                    readonly fields: {
+                        readonly type: "object";
+                        readonly patternProperties: {
+                            readonly '^[a-zA-Z][a-zA-Z0-9._-]*$': {
+                                readonly oneOf: readonly [{
+                                    readonly type: "string";
+                                    readonly maxLength: 1024;
+                                }, {
+                                    readonly type: "number";
+                                }, {
+                                    readonly type: "boolean";
+                                }];
+                            };
+                        };
+                        readonly additionalProperties: false;
+                    };
+                };
+            };
+            readonly maxItems: 100;
+            readonly description: "Structured log events within the span";
+        };
+        readonly status: {
+            readonly type: "string";
+            readonly enum: readonly ["OK", "CANCELLED", "UNKNOWN", "INVALID_ARGUMENT", "DEADLINE_EXCEEDED", "NOT_FOUND", "ALREADY_EXISTS", "PERMISSION_DENIED", "RESOURCE_EXHAUSTED", "FAILED_PRECONDITION", "ABORTED", "OUT_OF_RANGE", "UNIMPLEMENTED", "INTERNAL", "UNAVAILABLE", "DATA_LOSS", "UNAUTHENTICATED"];
+            readonly description: "Span status indicating success or failure";
+        };
+    };
+    readonly additionalProperties: false;
+};
+export declare const TraceSchema: {
+    readonly type: "object";
+    readonly required: readonly ["traceId", "spans", "startTime"];
+    readonly properties: {
+        readonly traceId: {
+            readonly type: "string";
+            readonly pattern: "^[a-f0-9]{32}$";
+            readonly description: "Hexadecimal trace ID (32 characters)";
+        };
+        readonly spans: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly required: readonly ["traceId", "spanId", "operationName", "startTime", "tags", "status"];
+                readonly properties: {
+                    readonly traceId: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-f0-9]{32}$";
+                        readonly description: "Hexadecimal trace ID (32 characters)";
+                    };
+                    readonly spanId: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-f0-9]{16}$";
+                        readonly description: "Hexadecimal span ID (16 characters)";
+                    };
+                    readonly parentSpanId: {
+                        readonly type: "string";
+                        readonly pattern: "^[a-f0-9]{16}$";
+                        readonly description: "Hexadecimal parent span ID (16 characters)";
+                    };
+                    readonly operationName: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly maxLength: 256;
+                        readonly description: "Name of the operation being traced";
+                    };
+                    readonly startTime: {
+                        readonly type: "number";
+                        readonly minimum: 0;
+                        readonly description: "Start time in microseconds since epoch";
+                    };
+                    readonly endTime: {
+                        readonly type: "number";
+                        readonly minimum: 0;
+                        readonly description: "End time in microseconds since epoch";
+                    };
+                    readonly duration: {
+                        readonly type: "number";
+                        readonly minimum: 0;
+                        readonly description: "Duration in microseconds";
+                    };
+                    readonly tags: {
+                        readonly type: "object";
+                        readonly patternProperties: {
+                            readonly '^[a-zA-Z][a-zA-Z0-9._-]*$': {
+                                readonly oneOf: readonly [{
+                                    readonly type: "string";
+                                    readonly maxLength: 1024;
+                                }, {
+                                    readonly type: "number";
+                                }, {
+                                    readonly type: "boolean";
+                                }];
+                            };
+                        };
+                        readonly additionalProperties: false;
+                        readonly description: "Key-value pairs providing additional context";
+                    };
+                    readonly logs: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "object";
+                            readonly required: readonly ["timestamp", "fields"];
+                            readonly properties: {
+                                readonly timestamp: {
+                                    readonly type: "number";
+                                    readonly minimum: 0;
+                                    readonly description: "Log timestamp in microseconds since epoch";
+                                };
+                                readonly fields: {
+                                    readonly type: "object";
+                                    readonly patternProperties: {
+                                        readonly '^[a-zA-Z][a-zA-Z0-9._-]*$': {
+                                            readonly oneOf: readonly [{
+                                                readonly type: "string";
+                                                readonly maxLength: 1024;
+                                            }, {
+                                                readonly type: "number";
+                                            }, {
+                                                readonly type: "boolean";
+                                            }];
+                                        };
+                                    };
+                                    readonly additionalProperties: false;
+                                };
+                            };
+                        };
+                        readonly maxItems: 100;
+                        readonly description: "Structured log events within the span";
+                    };
+                    readonly status: {
+                        readonly type: "string";
+                        readonly enum: readonly ["OK", "CANCELLED", "UNKNOWN", "INVALID_ARGUMENT", "DEADLINE_EXCEEDED", "NOT_FOUND", "ALREADY_EXISTS", "PERMISSION_DENIED", "RESOURCE_EXHAUSTED", "FAILED_PRECONDITION", "ABORTED", "OUT_OF_RANGE", "UNIMPLEMENTED", "INTERNAL", "UNAVAILABLE", "DATA_LOSS", "UNAUTHENTICATED"];
+                        readonly description: "Span status indicating success or failure";
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+            readonly minItems: 1;
+            readonly maxItems: 1000;
+            readonly description: "Array of spans that make up this trace";
+        };
+        readonly startTime: {
+            readonly type: "number";
+            readonly minimum: 0;
+            readonly description: "Trace start time in microseconds since epoch";
+        };
+        readonly endTime: {
+            readonly type: "number";
+            readonly minimum: 0;
+            readonly description: "Trace end time in microseconds since epoch";
+        };
+        readonly duration: {
+            readonly type: "number";
+            readonly minimum: 0;
+            readonly description: "Total trace duration in microseconds";
+        };
+        readonly rootSpan: {
+            readonly type: "object";
+            readonly required: readonly ["traceId", "spanId", "operationName", "startTime", "tags", "status"];
+            readonly properties: {
+                readonly traceId: {
+                    readonly type: "string";
+                    readonly pattern: "^[a-f0-9]{32}$";
+                    readonly description: "Hexadecimal trace ID (32 characters)";
+                };
+                readonly spanId: {
+                    readonly type: "string";
+                    readonly pattern: "^[a-f0-9]{16}$";
+                    readonly description: "Hexadecimal span ID (16 characters)";
+                };
+                readonly parentSpanId: {
+                    readonly type: "string";
+                    readonly pattern: "^[a-f0-9]{16}$";
+                    readonly description: "Hexadecimal parent span ID (16 characters)";
+                };
+                readonly operationName: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                    readonly maxLength: 256;
+                    readonly description: "Name of the operation being traced";
+                };
+                readonly startTime: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                    readonly description: "Start time in microseconds since epoch";
+                };
+                readonly endTime: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                    readonly description: "End time in microseconds since epoch";
+                };
+                readonly duration: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                    readonly description: "Duration in microseconds";
+                };
+                readonly tags: {
+                    readonly type: "object";
+                    readonly patternProperties: {
+                        readonly '^[a-zA-Z][a-zA-Z0-9._-]*$': {
+                            readonly oneOf: readonly [{
+                                readonly type: "string";
+                                readonly maxLength: 1024;
+                            }, {
+                                readonly type: "number";
+                            }, {
+                                readonly type: "boolean";
+                            }];
+                        };
+                    };
+                    readonly additionalProperties: false;
+                    readonly description: "Key-value pairs providing additional context";
+                };
+                readonly logs: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly required: readonly ["timestamp", "fields"];
+                        readonly properties: {
+                            readonly timestamp: {
+                                readonly type: "number";
+                                readonly minimum: 0;
+                                readonly description: "Log timestamp in microseconds since epoch";
+                            };
+                            readonly fields: {
+                                readonly type: "object";
+                                readonly patternProperties: {
+                                    readonly '^[a-zA-Z][a-zA-Z0-9._-]*$': {
+                                        readonly oneOf: readonly [{
+                                            readonly type: "string";
+                                            readonly maxLength: 1024;
+                                        }, {
+                                            readonly type: "number";
+                                        }, {
+                                            readonly type: "boolean";
+                                        }];
+                                    };
+                                };
+                                readonly additionalProperties: false;
+                            };
+                        };
+                    };
+                    readonly maxItems: 100;
+                    readonly description: "Structured log events within the span";
+                };
+                readonly status: {
+                    readonly type: "string";
+                    readonly enum: readonly ["OK", "CANCELLED", "UNKNOWN", "INVALID_ARGUMENT", "DEADLINE_EXCEEDED", "NOT_FOUND", "ALREADY_EXISTS", "PERMISSION_DENIED", "RESOURCE_EXHAUSTED", "FAILED_PRECONDITION", "ABORTED", "OUT_OF_RANGE", "UNIMPLEMENTED", "INTERNAL", "UNAVAILABLE", "DATA_LOSS", "UNAUTHENTICATED"];
+                    readonly description: "Span status indicating success or failure";
+                };
+            };
+            readonly additionalProperties: false;
+        };
+    };
+    readonly additionalProperties: false;
+};
+//# sourceMappingURL=trace.schema.d.ts.map

package/dist/schemas/trace.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/trace.schema.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4GlB,CAAC;AAEX,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCd,CAAC"}

package/dist/schemas/trace.schema.js

@@ -0,0 +1,145 @@
+// Trace span event schema for TraceLens
+export const TraceSpanSchema = {
+    type: 'object',
+    required: ['traceId', 'spanId', 'operationName', 'startTime', 'tags', 'status'],
+    properties: {
+        traceId: {
+            type: 'string',
+            pattern: '^[a-f0-9]{32}$',
+            description: 'Hexadecimal trace ID (32 characters)'
+        },
+        spanId: {
+            type: 'string',
+            pattern: '^[a-f0-9]{16}$',
+            description: 'Hexadecimal span ID (16 characters)'
+        },
+        parentSpanId: {
+            type: 'string',
+            pattern: '^[a-f0-9]{16}$',
+            description: 'Hexadecimal parent span ID (16 characters)'
+        },
+        operationName: {
+            type: 'string',
+            minLength: 1,
+            maxLength: 256,
+            description: 'Name of the operation being traced'
+        },
+        startTime: {
+            type: 'number',
+            minimum: 0,
+            description: 'Start time in microseconds since epoch'
+        },
+        endTime: {
+            type: 'number',
+            minimum: 0,
+            description: 'End time in microseconds since epoch'
+        },
+        duration: {
+            type: 'number',
+            minimum: 0,
+            description: 'Duration in microseconds'
+        },
+        tags: {
+            type: 'object',
+            patternProperties: {
+                '^[a-zA-Z][a-zA-Z0-9._-]*$': {
+                    oneOf: [
+                        { type: 'string', maxLength: 1024 },
+                        { type: 'number' },
+                        { type: 'boolean' }
+                    ]
+                }
+            },
+            additionalProperties: false,
+            description: 'Key-value pairs providing additional context'
+        },
+        logs: {
+            type: 'array',
+            items: {
+                type: 'object',
+                required: ['timestamp', 'fields'],
+                properties: {
+                    timestamp: {
+                        type: 'number',
+                        minimum: 0,
+                        description: 'Log timestamp in microseconds since epoch'
+                    },
+                    fields: {
+                        type: 'object',
+                        patternProperties: {
+                            '^[a-zA-Z][a-zA-Z0-9._-]*$': {
+                                oneOf: [
+                                    { type: 'string', maxLength: 1024 },
+                                    { type: 'number' },
+                                    { type: 'boolean' }
+                                ]
+                            }
+                        },
+                        additionalProperties: false
+                    }
+                }
+            },
+            maxItems: 100,
+            description: 'Structured log events within the span'
+        },
+        status: {
+            type: 'string',
+            enum: [
+                'OK',
+                'CANCELLED',
+                'UNKNOWN',
+                'INVALID_ARGUMENT',
+                'DEADLINE_EXCEEDED',
+                'NOT_FOUND',
+                'ALREADY_EXISTS',
+                'PERMISSION_DENIED',
+                'RESOURCE_EXHAUSTED',
+                'FAILED_PRECONDITION',
+                'ABORTED',
+                'OUT_OF_RANGE',
+                'UNIMPLEMENTED',
+                'INTERNAL',
+                'UNAVAILABLE',
+                'DATA_LOSS',
+                'UNAUTHENTICATED'
+            ],
+            description: 'Span status indicating success or failure'
+        }
+    },
+    additionalProperties: false
+};
+export const TraceSchema = {
+    type: 'object',
+    required: ['traceId', 'spans', 'startTime'],
+    properties: {
+        traceId: {
+            type: 'string',
+            pattern: '^[a-f0-9]{32}$',
+            description: 'Hexadecimal trace ID (32 characters)'
+        },
+        spans: {
+            type: 'array',
+            items: TraceSpanSchema,
+            minItems: 1,
+            maxItems: 1000,
+            description: 'Array of spans that make up this trace'
+        },
+        startTime: {
+            type: 'number',
+            minimum: 0,
+            description: 'Trace start time in microseconds since epoch'
+        },
+        endTime: {
+            type: 'number',
+            minimum: 0,
+            description: 'Trace end time in microseconds since epoch'
+        },
+        duration: {
+            type: 'number',
+            minimum: 0,
+            description: 'Total trace duration in microseconds'
+        },
+        rootSpan: TraceSpanSchema
+    },
+    additionalProperties: false
+};