@loglayer/transport-new-relic 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Theo Gravity
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,103 @@
+# New Relic Transport for LogLayer
+
+[![NPM Version](https://img.shields.io/npm/v/%40loglayer%2Ftransport-new-relic)](https://www.npmjs.com/package/@loglayer/transport-new-relic)
+[![NPM Downloads](https://img.shields.io/npm/dm/%40loglayer%2Ftransport-new-relic)](https://www.npmjs.com/package/@loglayer/transport-new-relic)
+[![TypeScript](https://img.shields.io/badge/%3C%2F%3E-TypeScript-%230074c1.svg)](http://www.typescriptlang.org/)
+
+Ships logs to New Relic using their [Log API](https://docs.newrelic.com/docs/logs/log-api/introduction-log-api/). Features include:
+- Automatic gzip compression (configurable)
+- Retry mechanism with exponential backoff
+- Rate limiting support with configurable behavior
+- Validation of New Relic's API constraints
+- Error handling callback
+- Configurable endpoints for different regions
+
+## Installation
+
+```bash
+npm install loglayer @loglayer/transport-new-relic serialize-error
+```
+
+## Usage
+
+```typescript
+import { LogLayer } from 'loglayer'
+import { NewRelicTransport } from "@loglayer/transport-new-relic"
+import { serializeError } from "serialize-error";
+
+const log = new LogLayer({
+  errorSerializer: serializeError,
+  transport: new NewRelicTransport({
+    apiKey: "YOUR_NEW_RELIC_API_KEY",
+    endpoint: "https://log-api.newrelic.com/log/v1", // optional, this is the default
+    useCompression: true, // optional, defaults to true
+    maxRetries: 3, // optional, defaults to 3
+    retryDelay: 1000, // optional, base delay in ms, defaults to 1000
+    respectRateLimit: true, // optional, defaults to true
+    onError: (err) => {
+      console.error('Failed to send logs to New Relic:', err);
+    },
+    onDebug: (entry) => {
+      console.log('Log entry being sent:', entry);
+    },
+  })
+})
+
+// Use the logger
+log.info("This is a test message");
+log.withMetadata({ userId: "123" }).error("User not found");
+```
+
+## Configuration
+
+```typescript
+interface NewRelicTransportConfig {
+  /**
+   * Whether the transport is enabled. Default is true.
+   */
+  enabled?: boolean;
+  /**
+   * The New Relic API key
+   */
+  apiKey: string;
+  /**
+   * The New Relic Log API endpoint
+   * @default https://log-api.newrelic.com/log/v1
+   */
+  endpoint?: string;
+  /**
+   * Optional callback for error handling
+   */
+  onError?: (err: Error) => void;
+  /**
+   * Optional callback for debugging log entries
+   * Called with the validated entry before it is sent
+   */
+  onDebug?: (entry: Record<string, any>) => void;
+  /**
+   * Whether to use gzip compression
+   * @default true
+   */
+  useCompression?: boolean;
+  /**
+   * Number of retry attempts before giving up
+   * @default 3
+   */
+  maxRetries?: number;
+  /**
+   * Base delay between retries in milliseconds. 
+   * The actual delay will use exponential backoff with jitter.
+   * @default 1000
+   */
+  retryDelay?: number;
+  /**
+   * Whether to respect rate limiting by waiting when a 429 response is received
+   * @default true
+   */
+  respectRateLimit?: boolean;
+}
+```
+
+## Documentation
+
+For more details, visit [https://loglayer.dev/transports/new-relic](https://loglayer.dev/transports/new-relic) 

package/dist/index.cjs

@@ -0,0 +1,239 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/NewRelicTransport.ts
+var _transport = require('@loglayer/transport');
+var MAX_PAYLOAD_SIZE = 1e6;
+var MAX_ATTRIBUTES = 255;
+var MAX_ATTRIBUTE_NAME_LENGTH = 255;
+var MAX_ATTRIBUTE_VALUE_LENGTH = 4094;
+var ValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+var RateLimitError = class extends Error {
+  constructor(message, retryAfter) {
+    super(message);
+    this.retryAfter = retryAfter;
+    this.name = "RateLimitError";
+  }
+};
+function validateLogEntry(logEntry) {
+  if (logEntry.attributes) {
+    const attributeCount = Object.keys(logEntry.attributes).length;
+    if (attributeCount > MAX_ATTRIBUTES) {
+      throw new ValidationError(
+        `Log entry exceeds maximum number of attributes (${MAX_ATTRIBUTES}). Found: ${attributeCount}`
+      );
+    }
+    for (const [key, value] of Object.entries(logEntry.attributes)) {
+      if (key.length > MAX_ATTRIBUTE_NAME_LENGTH) {
+        throw new ValidationError(
+          `Attribute name '${key}' exceeds maximum length (${MAX_ATTRIBUTE_NAME_LENGTH}). Length: ${key.length}`
+        );
+      }
+      if (typeof value === "string" && value.length > MAX_ATTRIBUTE_VALUE_LENGTH) {
+        logEntry.attributes[key] = value.slice(0, MAX_ATTRIBUTE_VALUE_LENGTH);
+      }
+    }
+  }
+  return logEntry;
+}
+var NewRelicTransport = class extends _transport.LoggerlessTransport {
+  
+  
+  
+  
+  
+  
+  
+  
+  /**
+   * Creates a new instance of NewRelicTransport.
+   *
+   * @param config - Configuration options for the transport
+   * @param config.apiKey - New Relic API key for authentication
+   * @param config.endpoint - Optional custom endpoint URL (defaults to New Relic's Log API endpoint)
+   * @param config.onError - Optional error callback for handling errors
+   * @param config.onDebug - Optional callback for debugging log entries before they are sent
+   * @param config.useCompression - Whether to use gzip compression (defaults to true)
+   * @param config.maxRetries - Maximum number of retry attempts (defaults to 3)
+   * @param config.retryDelay - Base delay between retries in milliseconds (defaults to 1000)
+   * @param config.respectRateLimit - Whether to honor rate limiting headers (defaults to true)
+   */
+  constructor(config) {
+    super(config);
+    this.apiKey = config.apiKey;
+    this.endpoint = _nullishCoalesce(config.endpoint, () => ( "https://log-api.newrelic.com/log/v1"));
+    this.onError = config.onError;
+    this.onDebug = config.onDebug;
+    this.useCompression = _nullishCoalesce(config.useCompression, () => ( true));
+    this.maxRetries = _nullishCoalesce(config.maxRetries, () => ( 3));
+    this.retryDelay = _nullishCoalesce(config.retryDelay, () => ( 1e3));
+    this.respectRateLimit = _nullishCoalesce(config.respectRateLimit, () => ( true));
+  }
+  /**
+   * Processes and ships log entries to New Relic.
+   *
+   * This method:
+   * 1. Validates the message size
+   * 2. Creates and validates the log entry
+   * 3. Validates the final payload size
+   * 4. Asynchronously sends the log entry to New Relic
+   *
+   * The actual sending is done asynchronously in a fire-and-forget manner to maintain
+   * compatibility with the base transport class while still providing retry and error handling.
+   *
+   * @param params - Log parameters including level, messages, and metadata
+   * @param params.logLevel - The severity level of the log
+   * @param params.messages - Array of message strings to be joined
+   * @param params.data - Optional metadata to include with the log
+   * @param params.hasData - Whether metadata is present
+   * @returns The original messages array
+   * @throws {ValidationError} If the payload exceeds size limits or validation fails
+   */
+  shipToLogger({ logLevel, messages, data, hasData }) {
+    try {
+      const message = messages.join(" ");
+      const messageBytes = new TextEncoder().encode(message).length;
+      if (messageBytes > MAX_PAYLOAD_SIZE) {
+        throw new ValidationError(
+          `Payload size exceeds maximum of ${MAX_PAYLOAD_SIZE} bytes. Size: ${messageBytes} bytes`
+        );
+      }
+      const logEntry = {
+        timestamp: (/* @__PURE__ */ new Date()).getTime(),
+        level: logLevel,
+        log: message
+      };
+      if (data && hasData) {
+        Object.assign(logEntry, {
+          attributes: data
+        });
+      }
+      const validatedEntry = validateLogEntry(logEntry);
+      if (this.onDebug) {
+        this.onDebug(validatedEntry);
+      }
+      const payload = JSON.stringify([validatedEntry]);
+      const payloadBytes = new TextEncoder().encode(payload).length;
+      if (payloadBytes > MAX_PAYLOAD_SIZE) {
+        throw new ValidationError(
+          `Payload size exceeds maximum of ${MAX_PAYLOAD_SIZE} bytes. Size: ${payloadBytes} bytes`
+        );
+      }
+      (async () => {
+        try {
+          await sendWithRetry(
+            this.endpoint,
+            this.apiKey,
+            payload,
+            this.useCompression,
+            this.maxRetries,
+            this.retryDelay,
+            this.respectRateLimit
+          );
+        } catch (error) {
+          if (this.onError) {
+            this.onError(error instanceof Error ? error : new Error(String(error)));
+          }
+          if (error instanceof ValidationError) {
+            throw error;
+          }
+        }
+      })();
+    } catch (error) {
+      if (this.onError) {
+        this.onError(error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+    return messages;
+  }
+};
+async function compressData(data) {
+  const stream = new CompressionStream("gzip");
+  const writer = stream.writable.getWriter();
+  const encoder = new TextEncoder();
+  const chunks = [];
+  await writer.write(encoder.encode(data));
+  await writer.close();
+  const reader = stream.readable.getReader();
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+  const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+async function sendWithRetry(endpoint, apiKey, payload, useCompression, maxRetries, retryDelay, respectRateLimit = true) {
+  const payloadBytes = new TextEncoder().encode(payload).length;
+  if (payloadBytes > MAX_PAYLOAD_SIZE) {
+    throw new ValidationError(`Payload size exceeds maximum of ${MAX_PAYLOAD_SIZE} bytes. Size: ${payloadBytes} bytes`);
+  }
+  let lastError;
+  let compressedPayload;
+  if (useCompression) {
+    compressedPayload = await compressData(payload);
+    if (compressedPayload.length > MAX_PAYLOAD_SIZE) {
+      throw new ValidationError(
+        `Compressed payload size exceeds maximum of ${MAX_PAYLOAD_SIZE} bytes. Size: ${compressedPayload.length} bytes`
+      );
+    }
+  }
+  const headers = {
+    "Content-Type": "application/json",
+    "Api-Key": apiKey
+  };
+  if (useCompression) {
+    headers["Content-Encoding"] = "gzip";
+  }
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers,
+        body: useCompression ? compressedPayload : payload
+      });
+      if (response.status === 429) {
+        const retryAfter = Number.parseInt(response.headers.get("Retry-After") || "60", 10);
+        if (respectRateLimit) {
+          await new Promise((resolve) => setTimeout(resolve, retryAfter * 1e3));
+          attempt--;
+          continue;
+        }
+        throw new RateLimitError(`Rate limit exceeded. Retry after ${retryAfter} seconds`, retryAfter);
+      }
+      if (!response.ok) {
+        throw new Error(`Failed to send logs to New Relic: ${response.statusText}`);
+      }
+      return response;
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (error instanceof ValidationError) {
+        throw error;
+      }
+      if (!respectRateLimit && error instanceof RateLimitError) {
+        throw error;
+      }
+      if (attempt === maxRetries) {
+        throw new Error(`Failed to send logs after ${maxRetries} retries: ${lastError.message}`);
+      }
+      if (!(error instanceof RateLimitError)) {
+        const jitter = Math.random() * 200;
+        const delay = retryDelay * 2 ** attempt + jitter;
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+  }
+  throw lastError;
+}
+
+
+exports.NewRelicTransport = NewRelicTransport;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/loglayer/loglayer/packages/transports/new-relic/dist/index.cjs","../src/NewRelicTransport.ts"],"names":[],"mappings":"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","file":"/home/runner/work/loglayer/loglayer/packages/transports/new-relic/dist/index.cjs","sourcesContent":[null,"import type { LogLayerTransportParams } from \"@loglayer/transport\";\nimport type { LoggerlessTransportConfig } from \"@loglayer/transport\";\nimport { LoggerlessTransport } from \"@loglayer/transport\";\n\n// Constants defining New Relic's API limits\nconst MAX_PAYLOAD_SIZE = 1_000_000; // 1MB in bytes\nconst MAX_ATTRIBUTES = 255;\nconst MAX_ATTRIBUTE_NAME_LENGTH = 255;\nconst MAX_ATTRIBUTE_VALUE_LENGTH = 4094;\n\n/**\n * Error thrown when log entry validation fails.\n * This includes payload size, attribute count, and attribute name length validations.\n */\nclass ValidationError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"ValidationError\";\n  }\n}\n\n/**\n * Error thrown when New Relic's API rate limit is exceeded.\n * Contains the retry-after duration specified by the API.\n */\nclass RateLimitError extends Error {\n  constructor(\n    message: string,\n    public retryAfter: number,\n  ) {\n    super(message);\n    this.name = \"RateLimitError\";\n  }\n}\n\n/**\n * Configuration options for the New Relic transport.\n */\nexport interface NewRelicTransportConfig extends LoggerlessTransportConfig {\n  /**\n   * The New Relic API key\n   */\n  apiKey: string;\n  /**\n   * The New Relic Log API endpoint\n   * @default https://log-api.newrelic.com/log/v1\n   */\n  endpoint?: string;\n  /**\n   * Optional callback for error handling\n   */\n  onError?: (err: Error) => void;\n  /**\n   * Optional callback for debugging log entries before they are sent\n   */\n  onDebug?: (entry: Record<string, any>) => void;\n  /**\n   * Whether to use gzip compression\n   * @default true\n   */\n  useCompression?: boolean;\n  /**\n   * Number of retry attempts before giving up\n   * @default 3\n   */\n  maxRetries?: number;\n  /**\n   * Base delay between retries in milliseconds\n   * @default 1000\n   */\n  retryDelay?: number;\n  /**\n   * Whether to respect rate limiting by waiting when a 429 response is received\n   * @default true\n   */\n  respectRateLimit?: boolean;\n}\n\n/**\n * Validates a log entry against New Relic's constraints.\n * - Checks number of attributes (max 255)\n * - Validates attribute name length (max 255 characters)\n * - Truncates attribute values longer than 4094 characters\n *\n * @param logEntry - The log entry to validate\n * @returns The validated (and potentially modified) log entry\n * @throws {ValidationError} If validation fails\n */\nfunction validateLogEntry(logEntry: Record<string, any>) {\n  if (logEntry.attributes) {\n    // Check number of attributes\n    const attributeCount = Object.keys(logEntry.attributes).length;\n    if (attributeCount > MAX_ATTRIBUTES) {\n      throw new ValidationError(\n        `Log entry exceeds maximum number of attributes (${MAX_ATTRIBUTES}). Found: ${attributeCount}`,\n      );\n    }\n\n    // Check attribute names and values\n    for (const [key, value] of Object.entries(logEntry.attributes)) {\n      // Check attribute name length\n      if (key.length > MAX_ATTRIBUTE_NAME_LENGTH) {\n        throw new ValidationError(\n          `Attribute name '${key}' exceeds maximum length (${MAX_ATTRIBUTE_NAME_LENGTH}). Length: ${key.length}`,\n        );\n      }\n\n      // Check string value length\n      if (typeof value === \"string\" && value.length > MAX_ATTRIBUTE_VALUE_LENGTH) {\n        // Truncate the string value to the maximum length\n        logEntry.attributes[key] = value.slice(0, MAX_ATTRIBUTE_VALUE_LENGTH);\n      }\n    }\n  }\n\n  return logEntry;\n}\n\n/**\n * NewRelicTransport is responsible for sending logs to New Relic's Log API.\n * It handles validation, compression, retries, and rate limiting according to New Relic's specifications.\n *\n * Features:\n * - Validates payload size (max 1MB)\n * - Validates number of attributes (max 255)\n * - Validates attribute name length (max 255 characters)\n * - Truncates attribute values longer than 4094 characters\n * - Supports gzip compression\n * - Handles rate limiting with configurable behavior\n * - Implements retry logic with exponential backoff\n */\nexport class NewRelicTransport extends LoggerlessTransport {\n  private apiKey: string;\n  private endpoint: string;\n  private onError?: (err: Error) => void;\n  private onDebug?: (entry: Record<string, any>) => void;\n  private useCompression: boolean;\n  private maxRetries: number;\n  private retryDelay: number;\n  private respectRateLimit: boolean;\n\n  /**\n   * Creates a new instance of NewRelicTransport.\n   *\n   * @param config - Configuration options for the transport\n   * @param config.apiKey - New Relic API key for authentication\n   * @param config.endpoint - Optional custom endpoint URL (defaults to New Relic's Log API endpoint)\n   * @param config.onError - Optional error callback for handling errors\n   * @param config.onDebug - Optional callback for debugging log entries before they are sent\n   * @param config.useCompression - Whether to use gzip compression (defaults to true)\n   * @param config.maxRetries - Maximum number of retry attempts (defaults to 3)\n   * @param config.retryDelay - Base delay between retries in milliseconds (defaults to 1000)\n   * @param config.respectRateLimit - Whether to honor rate limiting headers (defaults to true)\n   */\n  constructor(config: NewRelicTransportConfig) {\n    super(config);\n\n    this.apiKey = config.apiKey;\n    this.endpoint = config.endpoint ?? \"https://log-api.newrelic.com/log/v1\";\n    this.onError = config.onError;\n    this.onDebug = config.onDebug;\n    this.useCompression = config.useCompression ?? true;\n    this.maxRetries = config.maxRetries ?? 3;\n    this.retryDelay = config.retryDelay ?? 1000;\n    this.respectRateLimit = config.respectRateLimit ?? true;\n  }\n\n  /**\n   * Processes and ships log entries to New Relic.\n   *\n   * This method:\n   * 1. Validates the message size\n   * 2. Creates and validates the log entry\n   * 3. Validates the final payload size\n   * 4. Asynchronously sends the log entry to New Relic\n   *\n   * The actual sending is done asynchronously in a fire-and-forget manner to maintain\n   * compatibility with the base transport class while still providing retry and error handling.\n   *\n   * @param params - Log parameters including level, messages, and metadata\n   * @param params.logLevel - The severity level of the log\n   * @param params.messages - Array of message strings to be joined\n   * @param params.data - Optional metadata to include with the log\n   * @param params.hasData - Whether metadata is present\n   * @returns The original messages array\n   * @throws {ValidationError} If the payload exceeds size limits or validation fails\n   */\n  shipToLogger({ logLevel, messages, data, hasData }: LogLayerTransportParams): any[] {\n    try {\n      // Check message size first\n      const message = messages.join(\" \");\n      const messageBytes = new TextEncoder().encode(message).length;\n      if (messageBytes > MAX_PAYLOAD_SIZE) {\n        throw new ValidationError(\n          `Payload size exceeds maximum of ${MAX_PAYLOAD_SIZE} bytes. Size: ${messageBytes} bytes`,\n        );\n      }\n\n      const logEntry: Record<string, any> = {\n        timestamp: new Date().getTime(),\n        level: logLevel,\n        log: message,\n      };\n\n      if (data && hasData) {\n        Object.assign(logEntry, {\n          attributes: data,\n        });\n      }\n\n      const validatedEntry = validateLogEntry(logEntry);\n\n      // Call onDebug callback if defined\n      if (this.onDebug) {\n        this.onDebug(validatedEntry);\n      }\n\n      // Check final payload size\n      const payload = JSON.stringify([validatedEntry]);\n      const payloadBytes = new TextEncoder().encode(payload).length;\n      if (payloadBytes > MAX_PAYLOAD_SIZE) {\n        throw new ValidationError(\n          `Payload size exceeds maximum of ${MAX_PAYLOAD_SIZE} bytes. Size: ${payloadBytes} bytes`,\n        );\n      }\n\n      // Fire and forget the async processing\n      (async () => {\n        try {\n          await sendWithRetry(\n            this.endpoint,\n            this.apiKey,\n            payload,\n            this.useCompression,\n            this.maxRetries,\n            this.retryDelay,\n            this.respectRateLimit,\n          );\n        } catch (error) {\n          if (this.onError) {\n            this.onError(error instanceof Error ? error : new Error(String(error)));\n          }\n          // Re-throw validation errors to prevent further processing\n          if (error instanceof ValidationError) {\n            throw error;\n          }\n        }\n      })();\n    } catch (error) {\n      if (this.onError) {\n        this.onError(error instanceof Error ? error : new Error(String(error)));\n      }\n    }\n\n    return messages;\n  }\n}\n\n/**\n * Compresses data using gzip compression.\n *\n * @param data - The string data to compress\n * @returns A promise that resolves to the compressed data as a Uint8Array\n */\nasync function compressData(data: string): Promise<Uint8Array> {\n  const stream = new CompressionStream(\"gzip\");\n  const writer = stream.writable.getWriter();\n  const encoder = new TextEncoder();\n  const chunks: Uint8Array[] = [];\n\n  await writer.write(encoder.encode(data));\n  await writer.close();\n\n  const reader = stream.readable.getReader();\n\n  while (true) {\n    const { value, done } = await reader.read();\n    if (done) break;\n    chunks.push(value);\n  }\n\n  // Combine all chunks into a single Uint8Array\n  const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);\n  const result = new Uint8Array(totalLength);\n  let offset = 0;\n  for (const chunk of chunks) {\n    result.set(chunk, offset);\n    offset += chunk.length;\n  }\n\n  return result;\n}\n\n/**\n * Sends a log entry to New Relic with retry logic.\n * Handles rate limiting, compression, and error cases.\n *\n * @param endpoint - The New Relic API endpoint\n * @param apiKey - The New Relic API key\n * @param payload - The JSON payload to send\n * @param useCompression - Whether to use gzip compression\n * @param maxRetries - Maximum number of retry attempts\n * @param retryDelay - Base delay between retries in milliseconds\n * @param respectRateLimit - Whether to honor rate limiting headers\n * @returns A promise that resolves to the API response\n * @throws {ValidationError} If payload validation fails\n * @throws {RateLimitError} If rate limited and not respecting rate limits\n * @throws {Error} If the request fails after all retries\n */\nasync function sendWithRetry(\n  endpoint: string,\n  apiKey: string,\n  payload: string,\n  useCompression: boolean,\n  maxRetries: number,\n  retryDelay: number,\n  respectRateLimit = true,\n): Promise<Response> {\n  // Check payload size before compression\n  const payloadBytes = new TextEncoder().encode(payload).length;\n  if (payloadBytes > MAX_PAYLOAD_SIZE) {\n    throw new ValidationError(`Payload size exceeds maximum of ${MAX_PAYLOAD_SIZE} bytes. Size: ${payloadBytes} bytes`);\n  }\n\n  let lastError: Error;\n  let compressedPayload: Uint8Array | undefined;\n\n  if (useCompression) {\n    compressedPayload = await compressData(payload);\n    // Check compressed payload size\n    if (compressedPayload.length > MAX_PAYLOAD_SIZE) {\n      throw new ValidationError(\n        `Compressed payload size exceeds maximum of ${MAX_PAYLOAD_SIZE} bytes. Size: ${compressedPayload.length} bytes`,\n      );\n    }\n  }\n\n  const headers: Record<string, string> = {\n    \"Content-Type\": \"application/json\",\n    \"Api-Key\": apiKey,\n  };\n\n  if (useCompression) {\n    headers[\"Content-Encoding\"] = \"gzip\";\n  }\n\n  for (let attempt = 0; attempt <= maxRetries; attempt++) {\n    try {\n      const response = await fetch(endpoint, {\n        method: \"POST\",\n        headers,\n        body: useCompression ? compressedPayload : payload,\n      });\n\n      if (response.status === 429) {\n        const retryAfter = Number.parseInt(response.headers.get(\"Retry-After\") || \"60\", 10);\n        if (respectRateLimit) {\n          // Wait for the specified time before retrying\n          await new Promise((resolve) => setTimeout(resolve, retryAfter * 1000));\n          // Don't count rate limit retries against maxRetries\n          attempt--;\n          continue;\n        }\n\n        throw new RateLimitError(`Rate limit exceeded. Retry after ${retryAfter} seconds`, retryAfter);\n      }\n\n      if (!response.ok) {\n        throw new Error(`Failed to send logs to New Relic: ${response.statusText}`);\n      }\n\n      return response;\n    } catch (error) {\n      lastError = error instanceof Error ? error : new Error(String(error));\n\n      // Don't retry validation errors\n      if (error instanceof ValidationError) {\n        throw error;\n      }\n\n      // If we're not respecting rate limits, don't retry rate limit errors\n      if (!respectRateLimit && error instanceof RateLimitError) {\n        throw error;\n      }\n\n      if (attempt === maxRetries) {\n        throw new Error(`Failed to send logs after ${maxRetries} retries: ${lastError.message}`);\n      }\n\n      // For non-rate-limit errors, use exponential backoff with jitter\n      if (!(error instanceof RateLimitError)) {\n        const jitter = Math.random() * 200;\n        const delay = retryDelay * 2 ** attempt + jitter;\n        await new Promise((resolve) => setTimeout(resolve, delay));\n      }\n    }\n  }\n\n  throw lastError!;\n}\n"]}

package/dist/index.d.cts

@@ -0,0 +1,104 @@
+import { LoggerlessTransportConfig, LoggerlessTransport, LogLayerTransportParams } from '@loglayer/transport';
+
+/**
+ * Configuration options for the New Relic transport.
+ */
+interface NewRelicTransportConfig extends LoggerlessTransportConfig {
+    /**
+     * The New Relic API key
+     */
+    apiKey: string;
+    /**
+     * The New Relic Log API endpoint
+     * @default https://log-api.newrelic.com/log/v1
+     */
+    endpoint?: string;
+    /**
+     * Optional callback for error handling
+     */
+    onError?: (err: Error) => void;
+    /**
+     * Optional callback for debugging log entries before they are sent
+     */
+    onDebug?: (entry: Record<string, any>) => void;
+    /**
+     * Whether to use gzip compression
+     * @default true
+     */
+    useCompression?: boolean;
+    /**
+     * Number of retry attempts before giving up
+     * @default 3
+     */
+    maxRetries?: number;
+    /**
+     * Base delay between retries in milliseconds
+     * @default 1000
+     */
+    retryDelay?: number;
+    /**
+     * Whether to respect rate limiting by waiting when a 429 response is received
+     * @default true
+     */
+    respectRateLimit?: boolean;
+}
+/**
+ * NewRelicTransport is responsible for sending logs to New Relic's Log API.
+ * It handles validation, compression, retries, and rate limiting according to New Relic's specifications.
+ *
+ * Features:
+ * - Validates payload size (max 1MB)
+ * - Validates number of attributes (max 255)
+ * - Validates attribute name length (max 255 characters)
+ * - Truncates attribute values longer than 4094 characters
+ * - Supports gzip compression
+ * - Handles rate limiting with configurable behavior
+ * - Implements retry logic with exponential backoff
+ */
+declare class NewRelicTransport extends LoggerlessTransport {
+    private apiKey;
+    private endpoint;
+    private onError?;
+    private onDebug?;
+    private useCompression;
+    private maxRetries;
+    private retryDelay;
+    private respectRateLimit;
+    /**
+     * Creates a new instance of NewRelicTransport.
+     *
+     * @param config - Configuration options for the transport
+     * @param config.apiKey - New Relic API key for authentication
+     * @param config.endpoint - Optional custom endpoint URL (defaults to New Relic's Log API endpoint)
+     * @param config.onError - Optional error callback for handling errors
+     * @param config.onDebug - Optional callback for debugging log entries before they are sent
+     * @param config.useCompression - Whether to use gzip compression (defaults to true)
+     * @param config.maxRetries - Maximum number of retry attempts (defaults to 3)
+     * @param config.retryDelay - Base delay between retries in milliseconds (defaults to 1000)
+     * @param config.respectRateLimit - Whether to honor rate limiting headers (defaults to true)
+     */
+    constructor(config: NewRelicTransportConfig);
+    /**
+     * Processes and ships log entries to New Relic.
+     *
+     * This method:
+     * 1. Validates the message size
+     * 2. Creates and validates the log entry
+     * 3. Validates the final payload size
+     * 4. Asynchronously sends the log entry to New Relic
+     *
+     * The actual sending is done asynchronously in a fire-and-forget manner to maintain
+     * compatibility with the base transport class while still providing retry and error handling.
+     *
+     * @param params - Log parameters including level, messages, and metadata
+     * @param params.logLevel - The severity level of the log
+     * @param params.messages - Array of message strings to be joined
+     * @param params.data - Optional metadata to include with the log
+     * @param params.hasData - Whether metadata is present
+     * @returns The original messages array
+     * @throws {ValidationError} If the payload exceeds size limits or validation fails
+     */
+    shipToLogger({ logLevel, messages, data, hasData }: LogLayerTransportParams): any[];
+}
+
+export { NewRelicTransport, type NewRelicTransportConfig };

package/dist/index.d.ts

@@ -0,0 +1,104 @@
+import { LoggerlessTransportConfig, LoggerlessTransport, LogLayerTransportParams } from '@loglayer/transport';
+
+/**
+ * Configuration options for the New Relic transport.
+ */
+interface NewRelicTransportConfig extends LoggerlessTransportConfig {
+    /**
+     * The New Relic API key
+     */
+    apiKey: string;
+    /**
+     * The New Relic Log API endpoint
+     * @default https://log-api.newrelic.com/log/v1
+     */
+    endpoint?: string;
+    /**
+     * Optional callback for error handling
+     */
+    onError?: (err: Error) => void;
+    /**
+     * Optional callback for debugging log entries before they are sent
+     */
+    onDebug?: (entry: Record<string, any>) => void;
+    /**
+     * Whether to use gzip compression
+     * @default true
+     */
+    useCompression?: boolean;
+    /**
+     * Number of retry attempts before giving up
+     * @default 3
+     */
+    maxRetries?: number;
+    /**
+     * Base delay between retries in milliseconds
+     * @default 1000
+     */
+    retryDelay?: number;
+    /**
+     * Whether to respect rate limiting by waiting when a 429 response is received
+     * @default true
+     */
+    respectRateLimit?: boolean;
+}
+/**
+ * NewRelicTransport is responsible for sending logs to New Relic's Log API.
+ * It handles validation, compression, retries, and rate limiting according to New Relic's specifications.
+ *
+ * Features:
+ * - Validates payload size (max 1MB)
+ * - Validates number of attributes (max 255)
+ * - Validates attribute name length (max 255 characters)
+ * - Truncates attribute values longer than 4094 characters
+ * - Supports gzip compression
+ * - Handles rate limiting with configurable behavior
+ * - Implements retry logic with exponential backoff
+ */
+declare class NewRelicTransport extends LoggerlessTransport {
+    private apiKey;
+    private endpoint;
+    private onError?;
+    private onDebug?;
+    private useCompression;
+    private maxRetries;
+    private retryDelay;
+    private respectRateLimit;
+    /**
+     * Creates a new instance of NewRelicTransport.
+     *
+     * @param config - Configuration options for the transport
+     * @param config.apiKey - New Relic API key for authentication
+     * @param config.endpoint - Optional custom endpoint URL (defaults to New Relic's Log API endpoint)
+     * @param config.onError - Optional error callback for handling errors
+     * @param config.onDebug - Optional callback for debugging log entries before they are sent
+     * @param config.useCompression - Whether to use gzip compression (defaults to true)
+     * @param config.maxRetries - Maximum number of retry attempts (defaults to 3)
+     * @param config.retryDelay - Base delay between retries in milliseconds (defaults to 1000)
+     * @param config.respectRateLimit - Whether to honor rate limiting headers (defaults to true)
+     */
+    constructor(config: NewRelicTransportConfig);
+    /**
+     * Processes and ships log entries to New Relic.
+     *
+     * This method:
+     * 1. Validates the message size
+     * 2. Creates and validates the log entry
+     * 3. Validates the final payload size
+     * 4. Asynchronously sends the log entry to New Relic
+     *
+     * The actual sending is done asynchronously in a fire-and-forget manner to maintain
+     * compatibility with the base transport class while still providing retry and error handling.
+     *
+     * @param params - Log parameters including level, messages, and metadata
+     * @param params.logLevel - The severity level of the log
+     * @param params.messages - Array of message strings to be joined
+     * @param params.data - Optional metadata to include with the log
+     * @param params.hasData - Whether metadata is present
+     * @returns The original messages array
+     * @throws {ValidationError} If the payload exceeds size limits or validation fails
+     */
+    shipToLogger({ logLevel, messages, data, hasData }: LogLayerTransportParams): any[];
+}
+
+export { NewRelicTransport, type NewRelicTransportConfig };

package/dist/index.js

@@ -0,0 +1,239 @@
+// src/NewRelicTransport.ts
+import { LoggerlessTransport } from "@loglayer/transport";
+var MAX_PAYLOAD_SIZE = 1e6;
+var MAX_ATTRIBUTES = 255;
+var MAX_ATTRIBUTE_NAME_LENGTH = 255;
+var MAX_ATTRIBUTE_VALUE_LENGTH = 4094;
+var ValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+var RateLimitError = class extends Error {
+  constructor(message, retryAfter) {
+    super(message);
+    this.retryAfter = retryAfter;
+    this.name = "RateLimitError";
+  }
+};
+function validateLogEntry(logEntry) {
+  if (logEntry.attributes) {
+    const attributeCount = Object.keys(logEntry.attributes).length;
+    if (attributeCount > MAX_ATTRIBUTES) {
+      throw new ValidationError(
+        `Log entry exceeds maximum number of attributes (${MAX_ATTRIBUTES}). Found: ${attributeCount}`
+      );
+    }
+    for (const [key, value] of Object.entries(logEntry.attributes)) {
+      if (key.length > MAX_ATTRIBUTE_NAME_LENGTH) {
+        throw new ValidationError(
+          `Attribute name '${key}' exceeds maximum length (${MAX_ATTRIBUTE_NAME_LENGTH}). Length: ${key.length}`
+        );
+      }
+      if (typeof value === "string" && value.length > MAX_ATTRIBUTE_VALUE_LENGTH) {
+        logEntry.attributes[key] = value.slice(0, MAX_ATTRIBUTE_VALUE_LENGTH);
+      }
+    }
+  }
+  return logEntry;
+}
+var NewRelicTransport = class extends LoggerlessTransport {
+  apiKey;
+  endpoint;
+  onError;
+  onDebug;
+  useCompression;
+  maxRetries;
+  retryDelay;
+  respectRateLimit;
+  /**
+   * Creates a new instance of NewRelicTransport.
+   *
+   * @param config - Configuration options for the transport
+   * @param config.apiKey - New Relic API key for authentication
+   * @param config.endpoint - Optional custom endpoint URL (defaults to New Relic's Log API endpoint)
+   * @param config.onError - Optional error callback for handling errors
+   * @param config.onDebug - Optional callback for debugging log entries before they are sent
+   * @param config.useCompression - Whether to use gzip compression (defaults to true)
+   * @param config.maxRetries - Maximum number of retry attempts (defaults to 3)
+   * @param config.retryDelay - Base delay between retries in milliseconds (defaults to 1000)
+   * @param config.respectRateLimit - Whether to honor rate limiting headers (defaults to true)
+   */
+  constructor(config) {
+    super(config);
+    this.apiKey = config.apiKey;
+    this.endpoint = config.endpoint ?? "https://log-api.newrelic.com/log/v1";
+    this.onError = config.onError;
+    this.onDebug = config.onDebug;
+    this.useCompression = config.useCompression ?? true;
+    this.maxRetries = config.maxRetries ?? 3;
+    this.retryDelay = config.retryDelay ?? 1e3;
+    this.respectRateLimit = config.respectRateLimit ?? true;
+  }
+  /**
+   * Processes and ships log entries to New Relic.
+   *
+   * This method:
+   * 1. Validates the message size
+   * 2. Creates and validates the log entry
+   * 3. Validates the final payload size
+   * 4. Asynchronously sends the log entry to New Relic
+   *
+   * The actual sending is done asynchronously in a fire-and-forget manner to maintain
+   * compatibility with the base transport class while still providing retry and error handling.
+   *
+   * @param params - Log parameters including level, messages, and metadata
+   * @param params.logLevel - The severity level of the log
+   * @param params.messages - Array of message strings to be joined
+   * @param params.data - Optional metadata to include with the log
+   * @param params.hasData - Whether metadata is present
+   * @returns The original messages array
+   * @throws {ValidationError} If the payload exceeds size limits or validation fails
+   */
+  shipToLogger({ logLevel, messages, data, hasData }) {
+    try {
+      const message = messages.join(" ");
+      const messageBytes = new TextEncoder().encode(message).length;
+      if (messageBytes > MAX_PAYLOAD_SIZE) {
+        throw new ValidationError(
+          `Payload size exceeds maximum of ${MAX_PAYLOAD_SIZE} bytes. Size: ${messageBytes} bytes`
+        );
+      }
+      const logEntry = {
+        timestamp: (/* @__PURE__ */ new Date()).getTime(),
+        level: logLevel,
+        log: message
+      };
+      if (data && hasData) {
+        Object.assign(logEntry, {
+          attributes: data
+        });
+      }
+      const validatedEntry = validateLogEntry(logEntry);
+      if (this.onDebug) {
+        this.onDebug(validatedEntry);
+      }
+      const payload = JSON.stringify([validatedEntry]);
+      const payloadBytes = new TextEncoder().encode(payload).length;
+      if (payloadBytes > MAX_PAYLOAD_SIZE) {
+        throw new ValidationError(
+          `Payload size exceeds maximum of ${MAX_PAYLOAD_SIZE} bytes. Size: ${payloadBytes} bytes`
+        );
+      }
+      (async () => {
+        try {
+          await sendWithRetry(
+            this.endpoint,
+            this.apiKey,
+            payload,
+            this.useCompression,
+            this.maxRetries,
+            this.retryDelay,
+            this.respectRateLimit
+          );
+        } catch (error) {
+          if (this.onError) {
+            this.onError(error instanceof Error ? error : new Error(String(error)));
+          }
+          if (error instanceof ValidationError) {
+            throw error;
+          }
+        }
+      })();
+    } catch (error) {
+      if (this.onError) {
+        this.onError(error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+    return messages;
+  }
+};
+async function compressData(data) {
+  const stream = new CompressionStream("gzip");
+  const writer = stream.writable.getWriter();
+  const encoder = new TextEncoder();
+  const chunks = [];
+  await writer.write(encoder.encode(data));
+  await writer.close();
+  const reader = stream.readable.getReader();
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+  const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+async function sendWithRetry(endpoint, apiKey, payload, useCompression, maxRetries, retryDelay, respectRateLimit = true) {
+  const payloadBytes = new TextEncoder().encode(payload).length;
+  if (payloadBytes > MAX_PAYLOAD_SIZE) {
+    throw new ValidationError(`Payload size exceeds maximum of ${MAX_PAYLOAD_SIZE} bytes. Size: ${payloadBytes} bytes`);
+  }
+  let lastError;
+  let compressedPayload;
+  if (useCompression) {
+    compressedPayload = await compressData(payload);
+    if (compressedPayload.length > MAX_PAYLOAD_SIZE) {
+      throw new ValidationError(
+        `Compressed payload size exceeds maximum of ${MAX_PAYLOAD_SIZE} bytes. Size: ${compressedPayload.length} bytes`
+      );
+    }
+  }
+  const headers = {
+    "Content-Type": "application/json",
+    "Api-Key": apiKey
+  };
+  if (useCompression) {
+    headers["Content-Encoding"] = "gzip";
+  }
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers,
+        body: useCompression ? compressedPayload : payload
+      });
+      if (response.status === 429) {
+        const retryAfter = Number.parseInt(response.headers.get("Retry-After") || "60", 10);
+        if (respectRateLimit) {
+          await new Promise((resolve) => setTimeout(resolve, retryAfter * 1e3));
+          attempt--;
+          continue;
+        }
+        throw new RateLimitError(`Rate limit exceeded. Retry after ${retryAfter} seconds`, retryAfter);
+      }
+      if (!response.ok) {
+        throw new Error(`Failed to send logs to New Relic: ${response.statusText}`);
+      }
+      return response;
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (error instanceof ValidationError) {
+        throw error;
+      }
+      if (!respectRateLimit && error instanceof RateLimitError) {
+        throw error;
+      }
+      if (attempt === maxRetries) {
+        throw new Error(`Failed to send logs after ${maxRetries} retries: ${lastError.message}`);
+      }
+      if (!(error instanceof RateLimitError)) {
+        const jitter = Math.random() * 200;
+        const delay = retryDelay * 2 ** attempt + jitter;
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+  }
+  throw lastError;
+}
+export {
+  NewRelicTransport
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/NewRelicTransport.ts"],"sourcesContent":["import type { LogLayerTransportParams } from \"@loglayer/transport\";\nimport type { LoggerlessTransportConfig } from \"@loglayer/transport\";\nimport { LoggerlessTransport } from \"@loglayer/transport\";\n\n// Constants defining New Relic's API limits\nconst MAX_PAYLOAD_SIZE = 1_000_000; // 1MB in bytes\nconst MAX_ATTRIBUTES = 255;\nconst MAX_ATTRIBUTE_NAME_LENGTH = 255;\nconst MAX_ATTRIBUTE_VALUE_LENGTH = 4094;\n\n/**\n * Error thrown when log entry validation fails.\n * This includes payload size, attribute count, and attribute name length validations.\n */\nclass ValidationError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"ValidationError\";\n  }\n}\n\n/**\n * Error thrown when New Relic's API rate limit is exceeded.\n * Contains the retry-after duration specified by the API.\n */\nclass RateLimitError extends Error {\n  constructor(\n    message: string,\n    public retryAfter: number,\n  ) {\n    super(message);\n    this.name = \"RateLimitError\";\n  }\n}\n\n/**\n * Configuration options for the New Relic transport.\n */\nexport interface NewRelicTransportConfig extends LoggerlessTransportConfig {\n  /**\n   * The New Relic API key\n   */\n  apiKey: string;\n  /**\n   * The New Relic Log API endpoint\n   * @default https://log-api.newrelic.com/log/v1\n   */\n  endpoint?: string;\n  /**\n   * Optional callback for error handling\n   */\n  onError?: (err: Error) => void;\n  /**\n   * Optional callback for debugging log entries before they are sent\n   */\n  onDebug?: (entry: Record<string, any>) => void;\n  /**\n   * Whether to use gzip compression\n   * @default true\n   */\n  useCompression?: boolean;\n  /**\n   * Number of retry attempts before giving up\n   * @default 3\n   */\n  maxRetries?: number;\n  /**\n   * Base delay between retries in milliseconds\n   * @default 1000\n   */\n  retryDelay?: number;\n  /**\n   * Whether to respect rate limiting by waiting when a 429 response is received\n   * @default true\n   */\n  respectRateLimit?: boolean;\n}\n\n/**\n * Validates a log entry against New Relic's constraints.\n * - Checks number of attributes (max 255)\n * - Validates attribute name length (max 255 characters)\n * - Truncates attribute values longer than 4094 characters\n *\n * @param logEntry - The log entry to validate\n * @returns The validated (and potentially modified) log entry\n * @throws {ValidationError} If validation fails\n */\nfunction validateLogEntry(logEntry: Record<string, any>) {\n  if (logEntry.attributes) {\n    // Check number of attributes\n    const attributeCount = Object.keys(logEntry.attributes).length;\n    if (attributeCount > MAX_ATTRIBUTES) {\n      throw new ValidationError(\n        `Log entry exceeds maximum number of attributes (${MAX_ATTRIBUTES}). Found: ${attributeCount}`,\n      );\n    }\n\n    // Check attribute names and values\n    for (const [key, value] of Object.entries(logEntry.attributes)) {\n      // Check attribute name length\n      if (key.length > MAX_ATTRIBUTE_NAME_LENGTH) {\n        throw new ValidationError(\n          `Attribute name '${key}' exceeds maximum length (${MAX_ATTRIBUTE_NAME_LENGTH}). Length: ${key.length}`,\n        );\n      }\n\n      // Check string value length\n      if (typeof value === \"string\" && value.length > MAX_ATTRIBUTE_VALUE_LENGTH) {\n        // Truncate the string value to the maximum length\n        logEntry.attributes[key] = value.slice(0, MAX_ATTRIBUTE_VALUE_LENGTH);\n      }\n    }\n  }\n\n  return logEntry;\n}\n\n/**\n * NewRelicTransport is responsible for sending logs to New Relic's Log API.\n * It handles validation, compression, retries, and rate limiting according to New Relic's specifications.\n *\n * Features:\n * - Validates payload size (max 1MB)\n * - Validates number of attributes (max 255)\n * - Validates attribute name length (max 255 characters)\n * - Truncates attribute values longer than 4094 characters\n * - Supports gzip compression\n * - Handles rate limiting with configurable behavior\n * - Implements retry logic with exponential backoff\n */\nexport class NewRelicTransport extends LoggerlessTransport {\n  private apiKey: string;\n  private endpoint: string;\n  private onError?: (err: Error) => void;\n  private onDebug?: (entry: Record<string, any>) => void;\n  private useCompression: boolean;\n  private maxRetries: number;\n  private retryDelay: number;\n  private respectRateLimit: boolean;\n\n  /**\n   * Creates a new instance of NewRelicTransport.\n   *\n   * @param config - Configuration options for the transport\n   * @param config.apiKey - New Relic API key for authentication\n   * @param config.endpoint - Optional custom endpoint URL (defaults to New Relic's Log API endpoint)\n   * @param config.onError - Optional error callback for handling errors\n   * @param config.onDebug - Optional callback for debugging log entries before they are sent\n   * @param config.useCompression - Whether to use gzip compression (defaults to true)\n   * @param config.maxRetries - Maximum number of retry attempts (defaults to 3)\n   * @param config.retryDelay - Base delay between retries in milliseconds (defaults to 1000)\n   * @param config.respectRateLimit - Whether to honor rate limiting headers (defaults to true)\n   */\n  constructor(config: NewRelicTransportConfig) {\n    super(config);\n\n    this.apiKey = config.apiKey;\n    this.endpoint = config.endpoint ?? \"https://log-api.newrelic.com/log/v1\";\n    this.onError = config.onError;\n    this.onDebug = config.onDebug;\n    this.useCompression = config.useCompression ?? true;\n    this.maxRetries = config.maxRetries ?? 3;\n    this.retryDelay = config.retryDelay ?? 1000;\n    this.respectRateLimit = config.respectRateLimit ?? true;\n  }\n\n  /**\n   * Processes and ships log entries to New Relic.\n   *\n   * This method:\n   * 1. Validates the message size\n   * 2. Creates and validates the log entry\n   * 3. Validates the final payload size\n   * 4. Asynchronously sends the log entry to New Relic\n   *\n   * The actual sending is done asynchronously in a fire-and-forget manner to maintain\n   * compatibility with the base transport class while still providing retry and error handling.\n   *\n   * @param params - Log parameters including level, messages, and metadata\n   * @param params.logLevel - The severity level of the log\n   * @param params.messages - Array of message strings to be joined\n   * @param params.data - Optional metadata to include with the log\n   * @param params.hasData - Whether metadata is present\n   * @returns The original messages array\n   * @throws {ValidationError} If the payload exceeds size limits or validation fails\n   */\n  shipToLogger({ logLevel, messages, data, hasData }: LogLayerTransportParams): any[] {\n    try {\n      // Check message size first\n      const message = messages.join(\" \");\n      const messageBytes = new TextEncoder().encode(message).length;\n      if (messageBytes > MAX_PAYLOAD_SIZE) {\n        throw new ValidationError(\n          `Payload size exceeds maximum of ${MAX_PAYLOAD_SIZE} bytes. Size: ${messageBytes} bytes`,\n        );\n      }\n\n      const logEntry: Record<string, any> = {\n        timestamp: new Date().getTime(),\n        level: logLevel,\n        log: message,\n      };\n\n      if (data && hasData) {\n        Object.assign(logEntry, {\n          attributes: data,\n        });\n      }\n\n      const validatedEntry = validateLogEntry(logEntry);\n\n      // Call onDebug callback if defined\n      if (this.onDebug) {\n        this.onDebug(validatedEntry);\n      }\n\n      // Check final payload size\n      const payload = JSON.stringify([validatedEntry]);\n      const payloadBytes = new TextEncoder().encode(payload).length;\n      if (payloadBytes > MAX_PAYLOAD_SIZE) {\n        throw new ValidationError(\n          `Payload size exceeds maximum of ${MAX_PAYLOAD_SIZE} bytes. Size: ${payloadBytes} bytes`,\n        );\n      }\n\n      // Fire and forget the async processing\n      (async () => {\n        try {\n          await sendWithRetry(\n            this.endpoint,\n            this.apiKey,\n            payload,\n            this.useCompression,\n            this.maxRetries,\n            this.retryDelay,\n            this.respectRateLimit,\n          );\n        } catch (error) {\n          if (this.onError) {\n            this.onError(error instanceof Error ? error : new Error(String(error)));\n          }\n          // Re-throw validation errors to prevent further processing\n          if (error instanceof ValidationError) {\n            throw error;\n          }\n        }\n      })();\n    } catch (error) {\n      if (this.onError) {\n        this.onError(error instanceof Error ? error : new Error(String(error)));\n      }\n    }\n\n    return messages;\n  }\n}\n\n/**\n * Compresses data using gzip compression.\n *\n * @param data - The string data to compress\n * @returns A promise that resolves to the compressed data as a Uint8Array\n */\nasync function compressData(data: string): Promise<Uint8Array> {\n  const stream = new CompressionStream(\"gzip\");\n  const writer = stream.writable.getWriter();\n  const encoder = new TextEncoder();\n  const chunks: Uint8Array[] = [];\n\n  await writer.write(encoder.encode(data));\n  await writer.close();\n\n  const reader = stream.readable.getReader();\n\n  while (true) {\n    const { value, done } = await reader.read();\n    if (done) break;\n    chunks.push(value);\n  }\n\n  // Combine all chunks into a single Uint8Array\n  const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);\n  const result = new Uint8Array(totalLength);\n  let offset = 0;\n  for (const chunk of chunks) {\n    result.set(chunk, offset);\n    offset += chunk.length;\n  }\n\n  return result;\n}\n\n/**\n * Sends a log entry to New Relic with retry logic.\n * Handles rate limiting, compression, and error cases.\n *\n * @param endpoint - The New Relic API endpoint\n * @param apiKey - The New Relic API key\n * @param payload - The JSON payload to send\n * @param useCompression - Whether to use gzip compression\n * @param maxRetries - Maximum number of retry attempts\n * @param retryDelay - Base delay between retries in milliseconds\n * @param respectRateLimit - Whether to honor rate limiting headers\n * @returns A promise that resolves to the API response\n * @throws {ValidationError} If payload validation fails\n * @throws {RateLimitError} If rate limited and not respecting rate limits\n * @throws {Error} If the request fails after all retries\n */\nasync function sendWithRetry(\n  endpoint: string,\n  apiKey: string,\n  payload: string,\n  useCompression: boolean,\n  maxRetries: number,\n  retryDelay: number,\n  respectRateLimit = true,\n): Promise<Response> {\n  // Check payload size before compression\n  const payloadBytes = new TextEncoder().encode(payload).length;\n  if (payloadBytes > MAX_PAYLOAD_SIZE) {\n    throw new ValidationError(`Payload size exceeds maximum of ${MAX_PAYLOAD_SIZE} bytes. Size: ${payloadBytes} bytes`);\n  }\n\n  let lastError: Error;\n  let compressedPayload: Uint8Array | undefined;\n\n  if (useCompression) {\n    compressedPayload = await compressData(payload);\n    // Check compressed payload size\n    if (compressedPayload.length > MAX_PAYLOAD_SIZE) {\n      throw new ValidationError(\n        `Compressed payload size exceeds maximum of ${MAX_PAYLOAD_SIZE} bytes. Size: ${compressedPayload.length} bytes`,\n      );\n    }\n  }\n\n  const headers: Record<string, string> = {\n    \"Content-Type\": \"application/json\",\n    \"Api-Key\": apiKey,\n  };\n\n  if (useCompression) {\n    headers[\"Content-Encoding\"] = \"gzip\";\n  }\n\n  for (let attempt = 0; attempt <= maxRetries; attempt++) {\n    try {\n      const response = await fetch(endpoint, {\n        method: \"POST\",\n        headers,\n        body: useCompression ? compressedPayload : payload,\n      });\n\n      if (response.status === 429) {\n        const retryAfter = Number.parseInt(response.headers.get(\"Retry-After\") || \"60\", 10);\n        if (respectRateLimit) {\n          // Wait for the specified time before retrying\n          await new Promise((resolve) => setTimeout(resolve, retryAfter * 1000));\n          // Don't count rate limit retries against maxRetries\n          attempt--;\n          continue;\n        }\n\n        throw new RateLimitError(`Rate limit exceeded. Retry after ${retryAfter} seconds`, retryAfter);\n      }\n\n      if (!response.ok) {\n        throw new Error(`Failed to send logs to New Relic: ${response.statusText}`);\n      }\n\n      return response;\n    } catch (error) {\n      lastError = error instanceof Error ? error : new Error(String(error));\n\n      // Don't retry validation errors\n      if (error instanceof ValidationError) {\n        throw error;\n      }\n\n      // If we're not respecting rate limits, don't retry rate limit errors\n      if (!respectRateLimit && error instanceof RateLimitError) {\n        throw error;\n      }\n\n      if (attempt === maxRetries) {\n        throw new Error(`Failed to send logs after ${maxRetries} retries: ${lastError.message}`);\n      }\n\n      // For non-rate-limit errors, use exponential backoff with jitter\n      if (!(error instanceof RateLimitError)) {\n        const jitter = Math.random() * 200;\n        const delay = retryDelay * 2 ** attempt + jitter;\n        await new Promise((resolve) => setTimeout(resolve, delay));\n      }\n    }\n  }\n\n  throw lastError!;\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@loglayer/transport-new-relic",
+  "description": "New Relic transport for loglayer.",
+  "version": "1.0.1",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "exports": {
+    "import": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "require": {
+      "types": "./dist/index.d.cts",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "license": "MIT",
+  "repository": "loglayer/loglayer.git",
+  "author": "Theo Gravity <theo@suteki.nu>",
+  "keywords": [
+    "logging",
+    "log",
+    "loglayer",
+    "new-relic",
+    "newrelic",
+    "relic",
+    "transport"
+  ],
+  "dependencies": {
+    "@loglayer/transport": "1.1.2"
+  },
+  "devDependencies": {
+    "dotenv": "16.4.7",
+    "hash-runner": "2.0.1",
+    "@types/node": "22.10.4",
+    "serialize-error": "11.0.3",
+    "tsx": "4.19.2",
+    "tsup": "8.3.5",
+    "typescript": "5.7.2",
+    "vitest": "2.1.8",
+    "loglayer": "5.0.7",
+    "@internal/tsconfig": "1.0.0"
+  },
+  "bugs": "https://github.com/loglayer/loglayer/issues",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist"
+  ],
+  "homepage": "https://loglayer.dev",
+  "scripts": {
+    "build": "tsup src/index.ts",
+    "test": "vitest --run",
+    "build:dev": "hash-runner",
+    "clean": "rm -rf .turbo node_modules dist",
+    "lint": "biome check --write --unsafe src && biome format src --write && biome lint src --fix",
+    "verify-types": "tsc --noEmit",
+    "livetest": "tsx src/__tests__/livetest.ts"
+  }
+}