@logtape/logtape 1.0.0-dev.246 → 1.0.0-dev.247

package/formatter.ts

@@ -209,6 +209,130 @@ export interface TextFormatterOptions {
   format?: (values: FormattedValues) => string;
 }
 
+// Optimized helper functions for timestamp formatting
+function padZero(num: number): string {
+  return num < 10 ? `0${num}` : `${num}`;
+}
+
+function padThree(num: number): string {
+  return num < 10 ? `00${num}` : num < 100 ? `0${num}` : `${num}`;
+}
+
+// Pre-optimized timestamp formatter functions
+const timestampFormatters = {
+  "date-time-timezone": (ts: number): string => {
+    const d = new Date(ts);
+    const year = d.getUTCFullYear();
+    const month = padZero(d.getUTCMonth() + 1);
+    const day = padZero(d.getUTCDate());
+    const hour = padZero(d.getUTCHours());
+    const minute = padZero(d.getUTCMinutes());
+    const second = padZero(d.getUTCSeconds());
+    const ms = padThree(d.getUTCMilliseconds());
+    return `${year}-${month}-${day} ${hour}:${minute}:${second}.${ms} +00:00`;
+  },
+  "date-time-tz": (ts: number): string => {
+    const d = new Date(ts);
+    const year = d.getUTCFullYear();
+    const month = padZero(d.getUTCMonth() + 1);
+    const day = padZero(d.getUTCDate());
+    const hour = padZero(d.getUTCHours());
+    const minute = padZero(d.getUTCMinutes());
+    const second = padZero(d.getUTCSeconds());
+    const ms = padThree(d.getUTCMilliseconds());
+    return `${year}-${month}-${day} ${hour}:${minute}:${second}.${ms} +00`;
+  },
+  "date-time": (ts: number): string => {
+    const d = new Date(ts);
+    const year = d.getUTCFullYear();
+    const month = padZero(d.getUTCMonth() + 1);
+    const day = padZero(d.getUTCDate());
+    const hour = padZero(d.getUTCHours());
+    const minute = padZero(d.getUTCMinutes());
+    const second = padZero(d.getUTCSeconds());
+    const ms = padThree(d.getUTCMilliseconds());
+    return `${year}-${month}-${day} ${hour}:${minute}:${second}.${ms}`;
+  },
+  "time-timezone": (ts: number): string => {
+    const d = new Date(ts);
+    const hour = padZero(d.getUTCHours());
+    const minute = padZero(d.getUTCMinutes());
+    const second = padZero(d.getUTCSeconds());
+    const ms = padThree(d.getUTCMilliseconds());
+    return `${hour}:${minute}:${second}.${ms} +00:00`;
+  },
+  "time-tz": (ts: number): string => {
+    const d = new Date(ts);
+    const hour = padZero(d.getUTCHours());
+    const minute = padZero(d.getUTCMinutes());
+    const second = padZero(d.getUTCSeconds());
+    const ms = padThree(d.getUTCMilliseconds());
+    return `${hour}:${minute}:${second}.${ms} +00`;
+  },
+  "time": (ts: number): string => {
+    const d = new Date(ts);
+    const hour = padZero(d.getUTCHours());
+    const minute = padZero(d.getUTCMinutes());
+    const second = padZero(d.getUTCSeconds());
+    const ms = padThree(d.getUTCMilliseconds());
+    return `${hour}:${minute}:${second}.${ms}`;
+  },
+  "date": (ts: number): string => {
+    const d = new Date(ts);
+    const year = d.getUTCFullYear();
+    const month = padZero(d.getUTCMonth() + 1);
+    const day = padZero(d.getUTCDate());
+    return `${year}-${month}-${day}`;
+  },
+  "rfc3339": (ts: number): string => new Date(ts).toISOString(),
+  "none": (): null => null,
+} as const;
+
+// Pre-computed level renderers for common cases
+const levelRenderersCache = {
+  ABBR: levelAbbreviations,
+  abbr: {
+    trace: "trc",
+    debug: "dbg",
+    info: "inf",
+    warning: "wrn",
+    error: "err",
+    fatal: "ftl",
+  } as const,
+  FULL: {
+    trace: "TRACE",
+    debug: "DEBUG",
+    info: "INFO",
+    warning: "WARNING",
+    error: "ERROR",
+    fatal: "FATAL",
+  } as const,
+  full: {
+    trace: "trace",
+    debug: "debug",
+    info: "info",
+    warning: "warning",
+    error: "error",
+    fatal: "fatal",
+  } as const,
+  L: {
+    trace: "T",
+    debug: "D",
+    info: "I",
+    warning: "W",
+    error: "E",
+    fatal: "F",
+  } as const,
+  l: {
+    trace: "t",
+    debug: "d",
+    info: "i",
+    warning: "w",
+    error: "e",
+    fatal: "f",
+  } as const,
+} as const;
+
 /**
  * Get a text formatter with the specified options.  Although it's flexible
  * enough to create a custom formatter, if you want more control, you can
@@ -229,61 +353,81 @@ export interface TextFormatterOptions {
 export function getTextFormatter(
   options: TextFormatterOptions = {},
 ): TextFormatter {
-  const timestampRenderer =
-    options.timestamp == null || options.timestamp === "date-time-timezone"
-      ? (ts: number): string =>
-        new Date(ts).toISOString().replace("T", " ").replace("Z", " +00:00")
-      : options.timestamp === "date-time-tz"
-      ? (ts: number): string =>
-        new Date(ts).toISOString().replace("T", " ").replace("Z", " +00")
-      : options.timestamp === "date-time"
-      ? (ts: number): string =>
-        new Date(ts).toISOString().replace("T", " ").replace("Z", "")
-      : options.timestamp === "time-timezone"
-      ? (ts: number): string =>
-        new Date(ts).toISOString().replace(/.*T/, "").replace("Z", " +00:00")
-      : options.timestamp === "time-tz"
-      ? (ts: number): string =>
-        new Date(ts).toISOString().replace(/.*T/, "").replace("Z", " +00")
-      : options.timestamp === "time"
-      ? (ts: number): string =>
-        new Date(ts).toISOString().replace(/.*T/, "").replace("Z", "")
-      : options.timestamp === "date"
-      ? (ts: number): string => new Date(ts).toISOString().replace(/T.*/, "")
-      : options.timestamp === "rfc3339"
-      ? (ts: number): string => new Date(ts).toISOString()
-      : options.timestamp === "none" || options.timestamp === "disabled"
-      ? () => null
-      : options.timestamp;
+  // Pre-compute timestamp formatter with optimized lookup
+  const timestampRenderer = (() => {
+    const tsOption = options.timestamp;
+    if (tsOption == null) {
+      return timestampFormatters["date-time-timezone"];
+    } else if (tsOption === "disabled") {
+      return timestampFormatters["none"];
+    } else if (
+      typeof tsOption === "string" && tsOption in timestampFormatters
+    ) {
+      return timestampFormatters[tsOption as keyof typeof timestampFormatters];
+    } else {
+      return tsOption as (ts: number) => string | null;
+    }
+  })();
+
   const categorySeparator = options.category ?? "·";
   const valueRenderer = options.value ?? inspect;
-  const levelRenderer = options.level == null || options.level === "ABBR"
-    ? (level: LogLevel): string => levelAbbreviations[level]
-    : options.level === "abbr"
-    ? (level: LogLevel): string => levelAbbreviations[level].toLowerCase()
-    : options.level === "FULL"
-    ? (level: LogLevel): string => level.toUpperCase()
-    : options.level === "full"
-    ? (level: LogLevel): string => level
-    : options.level === "L"
-    ? (level: LogLevel): string => level.charAt(0).toUpperCase()
-    : options.level === "l"
-    ? (level: LogLevel): string => level.charAt(0)
-    : options.level;
+
+  // Pre-compute level renderer for better performance
+  const levelRenderer = (() => {
+    const levelOption = options.level;
+    if (levelOption == null || levelOption === "ABBR") {
+      return (level: LogLevel): string => levelRenderersCache.ABBR[level];
+    } else if (levelOption === "abbr") {
+      return (level: LogLevel): string => levelRenderersCache.abbr[level];
+    } else if (levelOption === "FULL") {
+      return (level: LogLevel): string => levelRenderersCache.FULL[level];
+    } else if (levelOption === "full") {
+      return (level: LogLevel): string => levelRenderersCache.full[level];
+    } else if (levelOption === "L") {
+      return (level: LogLevel): string => levelRenderersCache.L[level];
+    } else if (levelOption === "l") {
+      return (level: LogLevel): string => levelRenderersCache.l[level];
+    } else {
+      return levelOption;
+    }
+  })();
+
   const formatter: (values: FormattedValues) => string = options.format ??
     (({ timestamp, level, category, message }: FormattedValues) =>
       `${timestamp ? `${timestamp} ` : ""}[${level}] ${category}: ${message}`);
+
   return (record: LogRecord): string => {
-    let message = "";
-    for (let i = 0; i < record.message.length; i++) {
-      if (i % 2 === 0) message += record.message[i];
-      else message += valueRenderer(record.message[i]);
+    // Optimized message building
+    const msgParts = record.message;
+    const msgLen = msgParts.length;
+
+    let message: string;
+    if (msgLen === 1) {
+      // Fast path for simple messages with no interpolation
+      message = msgParts[0] as string;
+    } else if (msgLen <= 6) {
+      // Fast path for small messages - direct concatenation
+      message = "";
+      for (let i = 0; i < msgLen; i++) {
+        message += (i % 2 === 0) ? msgParts[i] : valueRenderer(msgParts[i]);
+      }
+    } else {
+      // Optimized path for larger messages - array join
+      const parts: string[] = new Array(msgLen);
+      for (let i = 0; i < msgLen; i++) {
+        parts[i] = (i % 2 === 0)
+          ? msgParts[i] as string
+          : valueRenderer(msgParts[i]);
+      }
+      message = parts.join("");
     }
+
     const timestamp = timestampRenderer(record.timestamp);
     const level = levelRenderer(record.level);
     const category = typeof categorySeparator === "function"
       ? categorySeparator(record.category)
       : record.category.join(categorySeparator);
+
     const values: FormattedValues = {
       timestamp,
       level,
@@ -574,6 +718,58 @@ export interface JsonLinesFormatterOptions {
 export function getJsonLinesFormatter(
   options: JsonLinesFormatterOptions = {},
 ): TextFormatter {
+  // Most common configuration - optimize for the default case
+  if (!options.categorySeparator && !options.message && !options.properties) {
+    // Ultra-minimalist path - eliminate all possible overhead
+    return (record: LogRecord): string => {
+      // Direct benchmark pattern match (most common case first)
+      if (record.message.length === 3) {
+        return JSON.stringify({
+          "@timestamp": new Date(record.timestamp).toISOString(),
+          level: record.level === "warning"
+            ? "WARN"
+            : record.level.toUpperCase(),
+          message: record.message[0] + JSON.stringify(record.message[1]) +
+            record.message[2],
+          logger: record.category.join("."),
+          properties: record.properties,
+        });
+      }
+
+      // Single message (second most common)
+      if (record.message.length === 1) {
+        return JSON.stringify({
+          "@timestamp": new Date(record.timestamp).toISOString(),
+          level: record.level === "warning"
+            ? "WARN"
+            : record.level.toUpperCase(),
+          message: record.message[0],
+          logger: record.category.join("."),
+          properties: record.properties,
+        });
+      }
+
+      // Complex messages (fallback)
+      let msg = record.message[0] as string;
+      for (let i = 1; i < record.message.length; i++) {
+        msg += (i & 1) ? JSON.stringify(record.message[i]) : record.message[i];
+      }
+
+      return JSON.stringify({
+        "@timestamp": new Date(record.timestamp).toISOString(),
+        level: record.level === "warning" ? "WARN" : record.level.toUpperCase(),
+        message: msg,
+        logger: record.category.join("."),
+        properties: record.properties,
+      });
+    };
+  }
+
+  // Pre-compile configuration for non-default cases
+  const isTemplateMessage = options.message === "template";
+  const propertiesOption = options.properties ?? "nest:properties";
+
+  // Pre-compile category joining strategy
   let joinCategory: (category: readonly string[]) => string | readonly string[];
   if (typeof options.categorySeparator === "function") {
     joinCategory = options.categorySeparator;
@@ -583,34 +779,11 @@ export function getJsonLinesFormatter(
       category.join(separator);
   }
 
-  let getMessage: TextFormatter;
-  if (options.message === "template") {
-    getMessage = (record: LogRecord): string => {
-      if (typeof record.rawMessage === "string") {
-        return record.rawMessage;
-      }
-      let msg = "";
-      for (let i = 0; i < record.rawMessage.length; i++) {
-        msg += i % 2 < 1 ? record.rawMessage[i] : "{}";
-      }
-      return msg;
-    };
-  } else {
-    getMessage = (record: LogRecord): string => {
-      let msg = "";
-      for (let i = 0; i < record.message.length; i++) {
-        msg += i % 2 < 1
-          ? record.message[i]
-          : JSON.stringify(record.message[i]);
-      }
-      return msg;
-    };
-  }
-
-  const propertiesOption = options.properties ?? "nest:properties";
+  // Pre-compile properties handling strategy
   let getProperties: (
     properties: Record<string, unknown>,
   ) => Record<string, unknown>;
+
   if (propertiesOption === "flatten") {
     getProperties = (properties) => properties;
   } else if (propertiesOption.startsWith("prepend:")) {
@@ -640,6 +813,38 @@ export function getJsonLinesFormatter(
     );
   }
 
+  // Pre-compile message rendering function
+  let getMessage: (record: LogRecord) => string;
+
+  if (isTemplateMessage) {
+    getMessage = (record: LogRecord): string => {
+      if (typeof record.rawMessage === "string") {
+        return record.rawMessage;
+      }
+      let msg = "";
+      for (let i = 0; i < record.rawMessage.length; i++) {
+        msg += i % 2 < 1 ? record.rawMessage[i] : "{}";
+      }
+      return msg;
+    };
+  } else {
+    getMessage = (record: LogRecord): string => {
+      const msgLen = record.message.length;
+
+      if (msgLen === 1) {
+        return record.message[0] as string;
+      }
+
+      let msg = "";
+      for (let i = 0; i < msgLen; i++) {
+        msg += (i % 2 < 1)
+          ? record.message[i]
+          : JSON.stringify(record.message[i]);
+      }
+      return msg;
+    };
+  }
+
   return (record: LogRecord): string => {
     return JSON.stringify({
       "@timestamp": new Date(record.timestamp).toISOString(),

package/logger.ts

@@ -1343,46 +1343,77 @@ export function parseMessageTemplate(
   template: string,
   properties: Record<string, unknown>,
 ): readonly unknown[] {
+  const length = template.length;
+  if (length === 0) return [""];
+
+  // Fast path: no placeholders
+  if (!template.includes("{")) return [template];
+
   const message: unknown[] = [];
-  let part = "";
-  for (let i = 0; i < template.length; i++) {
-    const char = template.charAt(i);
-    const nextChar = template.charAt(i + 1);
-
-    if (char === "{" && nextChar === "{") {
-      // Escaped { character
-      part = part + char;
-      i++;
-    } else if (char === "}" && nextChar === "}") {
-      // Escaped } character
-      part = part + char;
-      i++;
-    } else if (char === "{") {
-      // Start of a placeholder
-      message.push(part);
-      part = "";
-    } else if (char === "}") {
-      // End of a placeholder
+  let startIndex = 0;
+
+  for (let i = 0; i < length; i++) {
+    const char = template[i];
+
+    if (char === "{") {
+      const nextChar = i + 1 < length ? template[i + 1] : "";
+
+      if (nextChar === "{") {
+        // Escaped { character - skip and continue
+        i++; // Skip the next {
+        continue;
+      }
+
+      // Find the closing }
+      const closeIndex = template.indexOf("}", i + 1);
+      if (closeIndex === -1) {
+        // No closing } found, treat as literal text
+        continue;
+      }
+
+      // Add text before placeholder
+      const beforeText = template.slice(startIndex, i);
+      message.push(beforeText.replace(/{{/g, "{").replace(/}}/g, "}"));
+
+      // Extract and process placeholder key
+      const key = template.slice(i + 1, closeIndex);
+
+      // Resolve property value
       let prop: unknown;
-      if (part.match(/^\s*\*\s*$/)) {
-        prop = part in properties
-          ? properties[part]
+
+      // Check for wildcard patterns
+      const trimmedKey = key.trim();
+      if (trimmedKey === "*") {
+        // This is a wildcard pattern
+        prop = key in properties
+          ? properties[key]
           : "*" in properties
           ? properties["*"]
           : properties;
-      } else if (part.match(/^\s|\s$/)) {
-        prop = part in properties ? properties[part] : properties[part.trim()];
       } else {
-        prop = properties[part];
+        // Regular property lookup with possible whitespace handling
+        if (key !== trimmedKey) {
+          // Key has leading/trailing whitespace
+          prop = key in properties ? properties[key] : properties[trimmedKey];
+        } else {
+          // Key has no leading/trailing whitespace
+          prop = properties[key];
+        }
       }
+
       message.push(prop);
-      part = "";
-    } else {
-      // Default case
-      part = part + char;
+      i = closeIndex; // Move to the }
+      startIndex = i + 1;
+    } else if (char === "}" && i + 1 < length && template[i + 1] === "}") {
+      // Escaped } character - skip
+      i++; // Skip the next }
     }
   }
-  message.push(part);
+
+  // Add remaining text
+  const remainingText = template.slice(startIndex);
+  message.push(remainingText.replace(/{{/g, "{").replace(/}}/g, "}"));
+
   return message;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/logtape",
-  "version": "1.0.0-dev.246+c7630de7",
+  "version": "1.0.0-dev.247+ffe631a6",
   "description": "Simple logging library with zero dependencies for Deno/Node.js/Bun/browsers",
   "keywords": [
     "logging",