@hartl-services/medusa-base 0.2.0 → 0.3.0

package/.medusa/server/src/public/sentry-logger.js

@@ -0,0 +1,82 @@
+"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);
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VudHJ5LWxvZ2dlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9wdWJsaWMvc2VudHJ5LWxvZ2dlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQVlBLDREQTBDQztBQXRERCxxREFBc0M7QUFHdEM7Ozs7Ozs7O0dBUUc7QUFDSCxTQUFnQix3QkFBd0IsQ0FBQyxNQUFjO0lBQ3JELE1BQU0sYUFBYSxHQUFHLE1BQU0sQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFBO0lBQy9DLE1BQU0sWUFBWSxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFBO0lBRTdDLE9BQU87UUFDTCxLQUFLLEVBQUUsTUFBTSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDO1FBQ2hDLFNBQVMsRUFBRSxNQUFNLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUM7UUFDeEMsV0FBVyxFQUFFLE1BQU0sQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQztRQUM1QyxhQUFhLEVBQUUsTUFBTSxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDO1FBQ2hELFFBQVEsRUFBRSxNQUFNLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUM7UUFDdEMsUUFBUSxFQUFFLE1BQU0sQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQztRQUN0QyxPQUFPLEVBQUUsTUFBTSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDO1FBQ3BDLE9BQU8sRUFBRSxNQUFNLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUM7UUFDcEMsS0FBSyxFQUFFLE1BQU0sQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQztRQUNoQyxLQUFLLEVBQUUsTUFBTSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDO1FBQ2hDLE9BQU8sRUFBRSxNQUFNLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUM7UUFDcEMsSUFBSSxFQUFFLE1BQU0sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQztRQUM5QixJQUFJLEVBQUUsTUFBTSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDO1FBQzlCLHNFQUFzRTtRQUN0RSwyRUFBMkU7UUFDM0UsMERBQTBEO1FBQzFELElBQUksRUFBRSxDQUFDLE9BQU8sRUFBRSxFQUFFO1lBQ2hCLElBQUssT0FBbUIsWUFBWSxLQUFLLEVBQUUsQ0FBQztnQkFDMUMsTUFBTSxDQUFDLGdCQUFnQixDQUFDLE9BQU8sRUFBRSxFQUFFLEtBQUssRUFBRSxTQUFTLEVBQUUsQ0FBQyxDQUFBO1lBQ3hELENBQUM7WUFDRCxPQUFPLFlBQVksQ0FBQyxPQUFPLENBQUMsQ0FBQTtRQUM5QixDQUFDO1FBQ0QsR0FBRyxFQUFFLE1BQU0sQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQztRQUM1QixLQUFLLEVBQUUsQ0FBQyxjQUFjLEVBQUUsS0FBSyxFQUFFLEVBQUU7WUFDL0IsTUFBTSxTQUFTLEdBQ2IsS0FBSyxJQUFJLENBQUMsY0FBYyxZQUFZLEtBQUssQ0FBQyxDQUFDLENBQUMsY0FBYyxDQUFDLENBQUMsQ0FBQyxJQUFJLEtBQUssQ0FBQyxjQUFjLENBQUMsQ0FBQyxDQUFBO1lBQ3pGLE1BQU0sYUFBYSxHQUNqQixLQUFLLElBQUksT0FBTyxjQUFjLEtBQUssUUFBUSxDQUFDLENBQUMsQ0FBQyxjQUFjLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQTtZQUUxRSxNQUFNLENBQUMsZ0JBQWdCLENBQ3JCLFNBQVMsRUFDVCxhQUFhLENBQUMsQ0FBQyxDQUFDLEVBQUUsS0FBSyxFQUFFLEVBQUUsYUFBYSxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUN6RCxDQUFBO1lBRUQsT0FBTyxhQUFhLENBQUMsY0FBYyxFQUFFLEtBQUssQ0FBQyxDQUFBO1FBQzdDLENBQUM7S0FDRixDQUFBO0FBQ0gsQ0FBQyJ9

package/README.md

@@ -230,3 +230,26 @@ Affiliate 100 (`affiliate-validate-complete-cart`,
   instead of silently leaving partial state.
 - The base never swallows a participant error and never reads toggles here.
 
+
+## Sentry logger wrapper
+
+`@hartl-services/medusa-base/sentry-logger` exports `withSentryErrorReporting(logger)`,
+formerly published as `@hartl-services/medusa-sentry-logger`. 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 reports
+every `logger.error(...)` and every `Error` passed to `logger.warn(...)` (at
+level `warning`). It is a plain library import for `medusa-config.ts`, not a
+Medusa plugin feature, and needs `@sentry/node` (an optional peer dependency):
+
+```ts
+import { logger } from "@medusajs/framework/logger";
+import { withSentryErrorReporting } from "@hartl-services/medusa-base/sentry-logger";
+
+module.exports = defineConfig({
+  logger: withSentryErrorReporting(logger),
+  // ...
+});
+```
+
+Initialize Sentry in `instrumentation.ts` as usual; without a `SENTRY_DSN` the
+wrapper is inert.

package/dist/public/sentry-logger.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/public/sentry-logger.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

@@ -1,7 +1,7 @@
 {
   "name": "@hartl-services/medusa-base",
-  "version": "0.2.0",
-  "description": "Base plugin for Hartl Services Medusa shops: per-plugin feature toggles with a generic Admin settings page, a Store endpoint for storefronts, and enforcement helpers for plugin routes, subscribers and jobs.",
+  "version": "0.3.0",
+  "description": "Base plugin for Hartl Services Medusa shops: per-plugin feature toggles with a generic Admin settings page, a Store endpoint for storefronts, enforcement helpers, the complete-cart hook composition, and the Sentry logger wrapper.",
   "license": "MIT",
   "files": [
     ".medusa/server",
@@ -28,6 +28,11 @@
       "import": "./dist/public/index.js",
       "require": "./dist/public/index.js"
     },
+    "./sentry-logger": {
+      "types": "./dist/public/sentry-logger.d.ts",
+      "import": "./dist/public/sentry-logger.js",
+      "require": "./dist/public/sentry-logger.js"
+    },
     "./.medusa/server/src/modules/*": "./.medusa/server/src/modules/*/index.js",
     "./.medusa/server/src/*": "./.medusa/server/src/*",
     "./admin": {
@@ -41,6 +46,7 @@
     "@medusajs/js-sdk": "^2.19.0",
     "@medusajs/medusa": "^2.19.0",
     "@medusajs/ui": "^4.2.1",
+    "@sentry/node": "^10.74.0",
     "@tanstack/react-query": "^5.64.2",
     "react": "^18.3.1",
     "react-router-dom": "^7.18.2"
@@ -55,6 +61,7 @@
     "@medusajs/js-sdk": "2.19.0",
     "@medusajs/medusa": "2.19.0",
     "@medusajs/ui": "4.2.1",
+    "@sentry/node": "^10.74.0",
     "@swc/core": "^1.7.28",
     "@swc/jest": "^0.2.39",
     "@tanstack/react-query": "5.64.2",
@@ -72,6 +79,11 @@
   "engines": {
     "node": ">=20"
   },
+  "peerDependenciesMeta": {
+    "@sentry/node": {
+      "optional": true
+    }
+  },
   "scripts": {
     "build": "medusa plugin:build && tsc -p tsconfig.public.json",
     "dev": "medusa plugin:develop",