@hartl-services/medusa-sentry-logger 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hartl Services GmbH
+
+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,46 @@
+# Medusa Sentry Logger
+
+Wraps Medusa's `configModule.logger` so that every `logger.error(...)` call is
+also reported to Sentry.
+
+Medusa's HTTP error handler catches thrown route and workflow errors and only
+logs them, so Sentry's default Node integrations never see them. Wrapping the
+logger captures every error the framework already logs.
+
+Medusa's Redis Event Bus logs a failing subscriber's exception with
+`logger.warn(err)`, even after the final retry. The wrapper therefore also
+reports every `Error` passed to `warn`, at Sentry level `warning`; plain
+warning messages are not reported.
+
+This is a plain library, not a Medusa plugin: do not add it to `plugins`.
+
+## Installation in a shop
+
+```bash
+pnpm add @hartl-services/medusa-sentry-logger @sentry/node
+```
+
+`@sentry/node` is a peer dependency, so the logger reports through the same
+Sentry client your shop initializes. Initialize Sentry in `instrumentation.ts`:
+
+```ts
+import * as Sentry from "@sentry/node";
+
+export function register() {
+  Sentry.init({ dsn: process.env.SENTRY_DSN });
+}
+```
+
+Then wrap the logger in `medusa-config.ts`:
+
+```ts
+import { logger } from "@medusajs/framework/logger";
+import { withSentryErrorReporting } from "@hartl-services/medusa-sentry-logger";
+
+module.exports = defineConfig({
+  logger: withSentryErrorReporting(logger),
+  // ...
+});
+```
+
+Without a `SENTRY_DSN`, Sentry stays inactive and the logger behaves as before.

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import type { Logger } from "@medusajs/framework/types";
+/**
+ * Medusa's own HTTP error-handler middleware fully "handles" every thrown
+ * route/workflow error via logger.error(...) before it can ever reach an
+ * uncaught-exception process hook, so Sentry's default Node integrations
+ * never see it. Bridging logger.error(...) itself is the only place that
+ * reliably captures every error Medusa's framework already logs internally.
+ * Errors that Medusa logs through logger.warn(err) (failing event
+ * subscribers) are reported too, at warning level.
+ */
+export declare function withSentryErrorReporting(logger: Logger): Logger;

package/dist/index.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withSentryErrorReporting = withSentryErrorReporting;
+const Sentry = __importStar(require("@sentry/node"));
+/**
+ * Medusa's own HTTP error-handler middleware fully "handles" every thrown
+ * route/workflow error via logger.error(...) before it can ever reach an
+ * uncaught-exception process hook, so Sentry's default Node integrations
+ * never see it. Bridging logger.error(...) itself is the only place that
+ * reliably captures every error Medusa's framework already logs internally.
+ * Errors that Medusa logs through logger.warn(err) (failing event
+ * subscribers) are reported too, at warning level.
+ */
+function withSentryErrorReporting(logger) {
+    const originalError = logger.error.bind(logger);
+    const originalWarn = logger.warn.bind(logger);
+    return {
+        panic: logger.panic.bind(logger),
+        shouldLog: logger.shouldLog.bind(logger),
+        setLogLevel: logger.setLogLevel.bind(logger),
+        unsetLogLevel: logger.unsetLogLevel.bind(logger),
+        activity: logger.activity.bind(logger),
+        progress: logger.progress.bind(logger),
+        failure: logger.failure.bind(logger),
+        success: logger.success.bind(logger),
+        silly: logger.silly.bind(logger),
+        debug: logger.debug.bind(logger),
+        verbose: logger.verbose.bind(logger),
+        http: logger.http.bind(logger),
+        info: logger.info.bind(logger),
+        // Medusa's Redis Event Bus logs a failing subscriber's exception with
+        // warn(err), even on the final retry, so an Error passed to warn is a real
+        // failure too. Plain warning messages stay out of Sentry.
+        warn: (message) => {
+            if (message instanceof Error) {
+                Sentry.captureException(message, { level: "warning" });
+            }
+            return originalWarn(message);
+        },
+        log: logger.log.bind(logger),
+        error: (messageOrError, error) => {
+            const exception = error ?? (messageOrError instanceof Error ? messageOrError : new Error(messageOrError));
+            const loggerMessage = error && typeof messageOrError === "string" ? messageOrError : undefined;
+            Sentry.captureException(exception, loggerMessage ? { extra: { loggerMessage } } : undefined);
+            return originalError(messageOrError, error);
+        },
+    };
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@hartl-services/medusa-sentry-logger",
+  "version": "0.1.0",
+  "description": "Bridges Medusa's configModule.logger to Sentry, so logger.error(...) calls surface in error tracking without instrumenting every route handler.",
+  "license": "MIT",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/hartl-services-gmbh/services/food-supplements-e-commerce.git",
+    "directory": "plugins/sentry-logger"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "peerDependencies": {
+    "@medusajs/framework": "^2.19.0",
+    "@sentry/node": "^10.74.0"
+  },
+  "devDependencies": {
+    "@medusajs/framework": "2.19.0",
+    "@sentry/node": "^10.74.0",
+    "@swc/core": "^1.7.28",
+    "@swc/jest": "^0.2.39",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^20.12.11",
+    "jest": "^29.7.0",
+    "typescript": "^5.6.2"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit",
+    "test:unit": "jest"
+  }
+}