infront-logger 1.0.0

package/README.MD

@@ -0,0 +1,43 @@
+# Infront Logger
+## Logging done right
+
+The logger supports both writhing to file and to console.
+
+    npm i @infront/logger
+
+## Usage
+	const {BaseLogger} = require('@infront/logger');  
+	let options = {};
+	let logger = new BaseLogger("component1", options);  
+	logger.log("this is a test message");
+
+## Loggers
+
+### BaseLogger
+#### Methods
+- session(id)
+- log(msg)
+- info(msg)
+- error(err)
+- profile(action, options)
+- profileMem(options)
+
+### HttpLogger (extends BaseLogger)
+#### Methods
+- request(req)
+- response(res)
+- body(data)
+- success(req, res, body)
+- error(err)
+
+## options
+
+- dirname - The directory in which the logs will be created (default: "logs")
+- levels - An object of "level name : hierarchical value"
+- level - default level (default: info)
+- dateFormat : default "YYYY-MM-DD HH:mm:ss:ms"
+- maxFileSize: The maximum file size for a rotating file strategy (default: "30m")
+- maxFiles: The maximum number of files for a rotating file strategy (default: 2)
+- filename - name of the default log file (default: "logs.log")
+- errorFilename - name of the default error log file (default: "error.log")
+- console - boolean - should log to console (default: true)

package/dist/index.es.js

@@ -0,0 +1,355 @@
+require("winston-daily-rotate-file");
+const { format: format$1, createLogger, transports, addColors } = require("winston");
+const { inspect } = require("util");
+const colors = {
+  error: "red",
+  warn: "yellow",
+  info: "green",
+  http: "magenta",
+  debug: "white"
+};
+addColors(colors);
+const OPTIONS = {
+  dirname: "logs",
+  levels: {
+    error: 0,
+    warn: 1,
+    info: 2,
+    http: 3,
+    debug: 4
+  },
+  level: "info",
+  zippedArchive: false,
+  dateFormat: "YYYY-MM-DD HH:mm:ss:ms",
+  maxFiles: 2,
+  maxFileSize: "30m",
+  filename: "logs.log",
+  errorFilename: "error.log",
+  console: true,
+  exclude: [],
+  createSymlink: true,
+  symlinkName: "logs.log"
+};
+function errorToJSON(error) {
+  const { message, name, stack } = error;
+  return {
+    message,
+    name,
+    stack
+  };
+}
+function fileFormatter(options) {
+  return format$1.combine(
+    // format.errors({stack: true}),
+    {
+      transform: (info) => {
+        const args = [info.message, ...info[Symbol.for("splat")] || []];
+        info.message = args.filter(Boolean).map((arg) => {
+          if (arg instanceof Error) {
+            return errorToJSON(arg);
+          }
+          return arg;
+        });
+        const msg = args.map((arg) => {
+          if (typeof arg == "object")
+            return inspect(arg, { compact: false, depth: Infinity });
+          return arg;
+        }).join(" ");
+        info[Symbol.for("message")] = `${info[Symbol.for("level")]}: ${msg}${info.stack ? " " + info.stack : ""}`;
+        if (options.exclude.some((string) => msg.includes(string)))
+          return null;
+        return info;
+      }
+    },
+    format$1.timestamp({ format: options.dateFormat }),
+    format$1.json()
+  );
+}
+function consoleFormatter(options) {
+  return format$1.timestamp({ format: options.dateFormat }), format$1.colorize({ all: true });
+}
+function getFormatter(type, options) {
+  switch (type) {
+    case "file":
+      return fileFormatter(options);
+    case "access":
+      break;
+    case "console":
+      return consoleFormatter(options);
+  }
+}
+function createTransport(options) {
+  let formatter = getFormatter(options.format, options);
+  if (formatter) {
+    options.format = formatter;
+  } else {
+    delete options.format;
+  }
+  return new transports.DailyRotateFile(options);
+}
+class Logger {
+  constructor(options = {}) {
+    this.options = { ...OPTIONS, ...options };
+    let trans = [
+      createTransport({
+        ...this.options,
+        filename: this.options.filename,
+        symlinkName: this.options.filename
+      }),
+      createTransport({
+        ...this.options,
+        filename: this.options.errorFilename,
+        symlinkName: this.options.errorFilename,
+        level: "error"
+      })
+    ];
+    if (this.options.console) {
+      trans.push(new transports.Console({
+        format: getFormatter("console", this.options)
+      }));
+    }
+    this.logger = createLogger({
+      level: this.options.level,
+      levels: this.options.levels,
+      exitOnError: false,
+      // format,
+      transports: trans,
+      exceptionHandlers: [
+        new transports.Console(),
+        new transports.File({ filename: `${this.options.dirname}/${this.options.errorFilename}` })
+      ]
+    });
+  }
+}
+const redact$1 = (data, ...sensitiveKeysList) => {
+  var _a, _b;
+  if (typeof data === "object" && data !== null && !((_b = (_a = data == null ? void 0 : data.constructor) == null ? void 0 : _a.name) == null ? void 0 : _b.startsWith("model"))) {
+    if (Array.isArray(data)) {
+      return data.map((item) => redact$1(item, ...sensitiveKeysList));
+    }
+    const redactedData = {};
+    for (const key in data) {
+      if (data == null ? void 0 : data.hasOwnProperty(key)) {
+        if (sensitiveKeysList.includes(key)) {
+          redactedData[key] = "*****";
+        } else {
+          redactedData[key] = redact$1(data[key], ...sensitiveKeysList);
+        }
+      }
+    }
+    return redactedData;
+  } else {
+    return data;
+  }
+};
+const trim$1 = (data, length) => {
+  try {
+    let str = JSON.stringify(data);
+    if (str.length > length) {
+      return str.substring(0, length) + "... [TRIMMED]";
+    }
+    return data;
+  } catch (err) {
+    return "";
+  }
+};
+const http = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  redact: redact$1,
+  trim: trim$1
+}, Symbol.toStringTag, { value: "Module" }));
+function toFixedNumber(num, digits, base) {
+  const pow = Math.pow(base ?? 10, digits);
+  return Math.round(num * pow) / pow;
+}
+function bytesToMB$1(b) {
+  return toFixedNumber(b / 1024 / 1024, 2, 10);
+}
+function formatBytes$1(bytes, decimals = 2) {
+  if (!+bytes)
+    return "0 Bytes";
+  const k = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))}${sizes[i]}`;
+}
+const format = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  bytesToMB: bytesToMB$1,
+  formatBytes: formatBytes$1,
+  toFixedNumber
+}, Symbol.toStringTag, { value: "Module" }));
+const pick = (obj, ...keys) => Object.fromEntries(
+  keys.filter((key) => key in obj).map((key) => [key, obj[key]])
+);
+const omit$1 = (obj, ...keys) => {
+  const result = { ...obj };
+  keys.forEach(function(prop) {
+    delete result[prop];
+  });
+  return result;
+};
+const object = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  omit: omit$1,
+  pick
+}, Symbol.toStringTag, { value: "Module" }));
+const v8 = require("v8");
+const { bytesToMB } = format;
+function stats() {
+  try {
+    let h = v8.getHeapStatistics();
+    return {
+      "total_heap_size": bytesToMB(h.total_heap_size),
+      "total_heap_size_executable": bytesToMB(h.total_heap_size_executable),
+      "total_physical_size": bytesToMB(h.total_physical_size),
+      "total_available_size": bytesToMB(h.total_available_size),
+      "used_heap_size": bytesToMB(h.used_heap_size),
+      "heap_size_limit": bytesToMB(h.heap_size_limit),
+      "malloced_memory": bytesToMB(h.malloced_memory),
+      "peak_malloced_memory": bytesToMB(h.peak_malloced_memory),
+      "does_zap_garbage": h.does_zap_garbage,
+      "number_of_native_contexts": h.number_of_native_contexts,
+      "number_of_detached_contexts": h.number_of_detached_contexts
+    };
+  } catch (err) {
+    return {};
+  }
+}
+class BaseLogger {
+  constructor(component, options) {
+    this.logger = new Logger(options).logger.child({ component });
+    this.ctx = {};
+    this.startTime = Date.now();
+    this.absaluteStartTime = Date.now();
+  }
+  session(id) {
+    this.ctx.sessionID = id;
+    return this;
+  }
+  log() {
+    this.logger.info(...arguments, this.ctx);
+    this._stopMemProfile();
+  }
+  info() {
+    this.logger.info(...arguments, this.ctx);
+    this._stopMemProfile();
+  }
+  error() {
+    this.logger.error(...arguments, this.ctx);
+    this._stopMemProfile();
+  }
+  profile(action, options = {}) {
+    this.ctx.profiler = this.ctx.profiler || {};
+    if (action) {
+      let startTime = this.ctx.profiler[action] ? Date.now() - this.ctx.profiler[action] : this.startTime;
+      this.ctx.profiler[action] = Date.now() - startTime;
+    }
+    this.ctx.profiler.totalTime = Date.now() - this.absaluteStartTime;
+    if (!options.continue)
+      this.startTime = Date.now();
+    return this;
+  }
+  _stopMemProfile() {
+    if (this.memProfileInterval)
+      clearInterval(this.memProfileInterval);
+  }
+  profileMem(options = {}) {
+    this.ctx.maxMemory = this.ctx.maxMemory || 0;
+    this.ctx.memoryStats = this.ctx.memoryStats || [];
+    this.ctx.memoryUsage = this.ctx.memoryUsage || [];
+    this.ctx.memoryStatsIntervalMS = options.interval || 1e3;
+    this._stopMemProfile();
+    this.memProfileInterval = setInterval(() => {
+      let mem = stats();
+      this.ctx.memoryStats.push(mem);
+      this.ctx.memoryUsage.push(mem.used_heap_size);
+      if (mem.used_heap_size > this.ctx.maxMemory) {
+        this.ctx.maxMemory = mem.used_heap_size;
+      }
+    }, this.ctx.memoryStatsIntervalMS);
+    return this;
+  }
+  context(key, value) {
+    this.ctx[key] = value;
+    return this;
+  }
+}
+const { redact, trim } = http;
+const { formatBytes } = format;
+const { omit } = object;
+const MAX_BODY_LENGTH = 128;
+class HTTPLogger extends BaseLogger {
+  constructor(startTime, options = {}) {
+    super("http", options);
+    this.startTime = startTime || Date.now();
+  }
+  request(req) {
+    this.session(req.sessionID);
+    this.req = req;
+    return this;
+  }
+  response(res) {
+    this.res = res;
+    return this;
+  }
+  body(data) {
+    this.data = data;
+    return this;
+  }
+  _prepare() {
+    var _a, _b;
+    let req = this.req;
+    let res = this.res;
+    let body = this.data;
+    this.ctx.request = {
+      headers: redact(req.headers, "cookie"),
+      host: req.headers.host,
+      baseUrl: req.baseUrl,
+      url: req.originalUrl || req.url,
+      method: req.method,
+      body: redact(req.body, "password"),
+      params: req == null ? void 0 : req.params,
+      query: redact(req == null ? void 0 : req.query, "password"),
+      clientIP: ((_a = req == null ? void 0 : req.headers["x-forwarded-for"]) == null ? void 0 : _a.split(",")[0]) ?? (req == null ? void 0 : req.socket.remoteAddress)
+    };
+    this.ctx.response = {
+      headers: omit(res.getHeaders(), "set-cookie", "x-powered-by"),
+      statusCode: res.statusCode,
+      body: trim(body, MAX_BODY_LENGTH)
+    };
+    this.ctx.responseTimeMs = Date.now() - this.startTime;
+    this.ctx.responseSizeBytes = this.data ? JSON.stringify(this.data).length : 0;
+    this.ctx.user = (_b = req == null ? void 0 : req.user) == null ? void 0 : _b.id;
+  }
+  _message(msg) {
+    var _a;
+    let remoteAddress = this.req.ip || this.req._remoteAddress || this.req.connection && this.req.connection.remoteAddress || void 0;
+    let ip = this.ctx.request.clientIP;
+    let method = this.ctx.request.method;
+    let url = this.ctx.request.url;
+    let statusCode = this.ctx.response.statusCode;
+    let responseTimeMs = this.ctx.responseTimeMs + "ms";
+    let responseSize = formatBytes((_a = JSON.stringify(this.data)) == null ? void 0 : _a.length);
+    return `${method} ${url} ${statusCode} ${responseTimeMs} ${responseSize} ${ip} ${remoteAddress} ${msg || ""}`;
+  }
+  success(req, res, body) {
+    if (req)
+      this.request(req);
+    if (res)
+      this.response(res);
+    if (body)
+      this.body(body);
+    this._prepare();
+    super.info(this._message());
+  }
+  error(err) {
+    this._prepare();
+    super.error(this._message(err));
+  }
+}
+export {
+  BaseLogger,
+  HTTPLogger as HttpLogger
+};

package/dist/index.umd.js

@@ -0,0 +1,359 @@
+(function(global, factory) {
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.index = {}));
+})(this, function(exports2) {
+  "use strict";
+  require("winston-daily-rotate-file");
+  const { format: format$1, createLogger, transports, addColors } = require("winston");
+  const { inspect } = require("util");
+  const colors = {
+    error: "red",
+    warn: "yellow",
+    info: "green",
+    http: "magenta",
+    debug: "white"
+  };
+  addColors(colors);
+  const OPTIONS = {
+    dirname: "logs",
+    levels: {
+      error: 0,
+      warn: 1,
+      info: 2,
+      http: 3,
+      debug: 4
+    },
+    level: "info",
+    zippedArchive: false,
+    dateFormat: "YYYY-MM-DD HH:mm:ss:ms",
+    maxFiles: 2,
+    maxFileSize: "30m",
+    filename: "logs.log",
+    errorFilename: "error.log",
+    console: true,
+    exclude: [],
+    createSymlink: true,
+    symlinkName: "logs.log"
+  };
+  function errorToJSON(error) {
+    const { message, name, stack } = error;
+    return {
+      message,
+      name,
+      stack
+    };
+  }
+  function fileFormatter(options) {
+    return format$1.combine(
+      // format.errors({stack: true}),
+      {
+        transform: (info) => {
+          const args = [info.message, ...info[Symbol.for("splat")] || []];
+          info.message = args.filter(Boolean).map((arg) => {
+            if (arg instanceof Error) {
+              return errorToJSON(arg);
+            }
+            return arg;
+          });
+          const msg = args.map((arg) => {
+            if (typeof arg == "object")
+              return inspect(arg, { compact: false, depth: Infinity });
+            return arg;
+          }).join(" ");
+          info[Symbol.for("message")] = `${info[Symbol.for("level")]}: ${msg}${info.stack ? " " + info.stack : ""}`;
+          if (options.exclude.some((string) => msg.includes(string)))
+            return null;
+          return info;
+        }
+      },
+      format$1.timestamp({ format: options.dateFormat }),
+      format$1.json()
+    );
+  }
+  function consoleFormatter(options) {
+    return format$1.timestamp({ format: options.dateFormat }), format$1.colorize({ all: true });
+  }
+  function getFormatter(type, options) {
+    switch (type) {
+      case "file":
+        return fileFormatter(options);
+      case "access":
+        break;
+      case "console":
+        return consoleFormatter(options);
+    }
+  }
+  function createTransport(options) {
+    let formatter = getFormatter(options.format, options);
+    if (formatter) {
+      options.format = formatter;
+    } else {
+      delete options.format;
+    }
+    return new transports.DailyRotateFile(options);
+  }
+  class Logger {
+    constructor(options = {}) {
+      this.options = { ...OPTIONS, ...options };
+      let trans = [
+        createTransport({
+          ...this.options,
+          filename: this.options.filename,
+          symlinkName: this.options.filename
+        }),
+        createTransport({
+          ...this.options,
+          filename: this.options.errorFilename,
+          symlinkName: this.options.errorFilename,
+          level: "error"
+        })
+      ];
+      if (this.options.console) {
+        trans.push(new transports.Console({
+          format: getFormatter("console", this.options)
+        }));
+      }
+      this.logger = createLogger({
+        level: this.options.level,
+        levels: this.options.levels,
+        exitOnError: false,
+        // format,
+        transports: trans,
+        exceptionHandlers: [
+          new transports.Console(),
+          new transports.File({ filename: `${this.options.dirname}/${this.options.errorFilename}` })
+        ]
+      });
+    }
+  }
+  const redact$1 = (data, ...sensitiveKeysList) => {
+    var _a, _b;
+    if (typeof data === "object" && data !== null && !((_b = (_a = data == null ? void 0 : data.constructor) == null ? void 0 : _a.name) == null ? void 0 : _b.startsWith("model"))) {
+      if (Array.isArray(data)) {
+        return data.map((item) => redact$1(item, ...sensitiveKeysList));
+      }
+      const redactedData = {};
+      for (const key in data) {
+        if (data == null ? void 0 : data.hasOwnProperty(key)) {
+          if (sensitiveKeysList.includes(key)) {
+            redactedData[key] = "*****";
+          } else {
+            redactedData[key] = redact$1(data[key], ...sensitiveKeysList);
+          }
+        }
+      }
+      return redactedData;
+    } else {
+      return data;
+    }
+  };
+  const trim$1 = (data, length) => {
+    try {
+      let str = JSON.stringify(data);
+      if (str.length > length) {
+        return str.substring(0, length) + "... [TRIMMED]";
+      }
+      return data;
+    } catch (err) {
+      return "";
+    }
+  };
+  const http = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+    __proto__: null,
+    redact: redact$1,
+    trim: trim$1
+  }, Symbol.toStringTag, { value: "Module" }));
+  function toFixedNumber(num, digits, base) {
+    const pow = Math.pow(base ?? 10, digits);
+    return Math.round(num * pow) / pow;
+  }
+  function bytesToMB$1(b) {
+    return toFixedNumber(b / 1024 / 1024, 2, 10);
+  }
+  function formatBytes$1(bytes, decimals = 2) {
+    if (!+bytes)
+      return "0 Bytes";
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))}${sizes[i]}`;
+  }
+  const format = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+    __proto__: null,
+    bytesToMB: bytesToMB$1,
+    formatBytes: formatBytes$1,
+    toFixedNumber
+  }, Symbol.toStringTag, { value: "Module" }));
+  const pick = (obj, ...keys) => Object.fromEntries(
+    keys.filter((key) => key in obj).map((key) => [key, obj[key]])
+  );
+  const omit$1 = (obj, ...keys) => {
+    const result = { ...obj };
+    keys.forEach(function(prop) {
+      delete result[prop];
+    });
+    return result;
+  };
+  const object = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+    __proto__: null,
+    omit: omit$1,
+    pick
+  }, Symbol.toStringTag, { value: "Module" }));
+  const v8 = require("v8");
+  const { bytesToMB } = format;
+  function stats() {
+    try {
+      let h = v8.getHeapStatistics();
+      return {
+        "total_heap_size": bytesToMB(h.total_heap_size),
+        "total_heap_size_executable": bytesToMB(h.total_heap_size_executable),
+        "total_physical_size": bytesToMB(h.total_physical_size),
+        "total_available_size": bytesToMB(h.total_available_size),
+        "used_heap_size": bytesToMB(h.used_heap_size),
+        "heap_size_limit": bytesToMB(h.heap_size_limit),
+        "malloced_memory": bytesToMB(h.malloced_memory),
+        "peak_malloced_memory": bytesToMB(h.peak_malloced_memory),
+        "does_zap_garbage": h.does_zap_garbage,
+        "number_of_native_contexts": h.number_of_native_contexts,
+        "number_of_detached_contexts": h.number_of_detached_contexts
+      };
+    } catch (err) {
+      return {};
+    }
+  }
+  class BaseLogger {
+    constructor(component, options) {
+      this.logger = new Logger(options).logger.child({ component });
+      this.ctx = {};
+      this.startTime = Date.now();
+      this.absaluteStartTime = Date.now();
+    }
+    session(id) {
+      this.ctx.sessionID = id;
+      return this;
+    }
+    log() {
+      this.logger.info(...arguments, this.ctx);
+      this._stopMemProfile();
+    }
+    info() {
+      this.logger.info(...arguments, this.ctx);
+      this._stopMemProfile();
+    }
+    error() {
+      this.logger.error(...arguments, this.ctx);
+      this._stopMemProfile();
+    }
+    profile(action, options = {}) {
+      this.ctx.profiler = this.ctx.profiler || {};
+      if (action) {
+        let startTime = this.ctx.profiler[action] ? Date.now() - this.ctx.profiler[action] : this.startTime;
+        this.ctx.profiler[action] = Date.now() - startTime;
+      }
+      this.ctx.profiler.totalTime = Date.now() - this.absaluteStartTime;
+      if (!options.continue)
+        this.startTime = Date.now();
+      return this;
+    }
+    _stopMemProfile() {
+      if (this.memProfileInterval)
+        clearInterval(this.memProfileInterval);
+    }
+    profileMem(options = {}) {
+      this.ctx.maxMemory = this.ctx.maxMemory || 0;
+      this.ctx.memoryStats = this.ctx.memoryStats || [];
+      this.ctx.memoryUsage = this.ctx.memoryUsage || [];
+      this.ctx.memoryStatsIntervalMS = options.interval || 1e3;
+      this._stopMemProfile();
+      this.memProfileInterval = setInterval(() => {
+        let mem = stats();
+        this.ctx.memoryStats.push(mem);
+        this.ctx.memoryUsage.push(mem.used_heap_size);
+        if (mem.used_heap_size > this.ctx.maxMemory) {
+          this.ctx.maxMemory = mem.used_heap_size;
+        }
+      }, this.ctx.memoryStatsIntervalMS);
+      return this;
+    }
+    context(key, value) {
+      this.ctx[key] = value;
+      return this;
+    }
+  }
+  const { redact, trim } = http;
+  const { formatBytes } = format;
+  const { omit } = object;
+  const MAX_BODY_LENGTH = 128;
+  class HTTPLogger extends BaseLogger {
+    constructor(startTime, options = {}) {
+      super("http", options);
+      this.startTime = startTime || Date.now();
+    }
+    request(req) {
+      this.session(req.sessionID);
+      this.req = req;
+      return this;
+    }
+    response(res) {
+      this.res = res;
+      return this;
+    }
+    body(data) {
+      this.data = data;
+      return this;
+    }
+    _prepare() {
+      var _a, _b;
+      let req = this.req;
+      let res = this.res;
+      let body = this.data;
+      this.ctx.request = {
+        headers: redact(req.headers, "cookie"),
+        host: req.headers.host,
+        baseUrl: req.baseUrl,
+        url: req.originalUrl || req.url,
+        method: req.method,
+        body: redact(req.body, "password"),
+        params: req == null ? void 0 : req.params,
+        query: redact(req == null ? void 0 : req.query, "password"),
+        clientIP: ((_a = req == null ? void 0 : req.headers["x-forwarded-for"]) == null ? void 0 : _a.split(",")[0]) ?? (req == null ? void 0 : req.socket.remoteAddress)
+      };
+      this.ctx.response = {
+        headers: omit(res.getHeaders(), "set-cookie", "x-powered-by"),
+        statusCode: res.statusCode,
+        body: trim(body, MAX_BODY_LENGTH)
+      };
+      this.ctx.responseTimeMs = Date.now() - this.startTime;
+      this.ctx.responseSizeBytes = this.data ? JSON.stringify(this.data).length : 0;
+      this.ctx.user = (_b = req == null ? void 0 : req.user) == null ? void 0 : _b.id;
+    }
+    _message(msg) {
+      var _a;
+      let remoteAddress = this.req.ip || this.req._remoteAddress || this.req.connection && this.req.connection.remoteAddress || void 0;
+      let ip = this.ctx.request.clientIP;
+      let method = this.ctx.request.method;
+      let url = this.ctx.request.url;
+      let statusCode = this.ctx.response.statusCode;
+      let responseTimeMs = this.ctx.responseTimeMs + "ms";
+      let responseSize = formatBytes((_a = JSON.stringify(this.data)) == null ? void 0 : _a.length);
+      return `${method} ${url} ${statusCode} ${responseTimeMs} ${responseSize} ${ip} ${remoteAddress} ${msg || ""}`;
+    }
+    success(req, res, body) {
+      if (req)
+        this.request(req);
+      if (res)
+        this.response(res);
+      if (body)
+        this.body(body);
+      this._prepare();
+      super.info(this._message());
+    }
+    error(err) {
+      this._prepare();
+      super.error(this._message(err));
+    }
+  }
+  exports2.BaseLogger = BaseLogger;
+  exports2.HttpLogger = HTTPLogger;
+  Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
+});

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "infront-logger",
+  "version": "1.0.0",
+  "description": "",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.umd.js",
+  "module": "./dist/index.es.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index.es.js",
+      "require": "./dist/index.umd.js"
+    }
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@esbuild-plugins/node-globals-polyfill": "^0.2.3",
+    "@esbuild-plugins/node-modules-polyfill": "^0.2.2",
+    "vite": "^5.0.12"
+  },
+  "dependencies": {
+    "winston": "^3.11.0",
+    "winston-daily-rotate-file": "^4.7.1",
+    "infront-utils": "^1.0.0"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  }
+}