@statoss/sdk 0.1.1 → 0.3.0

package/README.md

@@ -252,20 +252,105 @@ The Edge runtime has no global error hook either: capture where you handle
 errors and `await StatOSS.flush(2000)` (or pass it to `waitUntil`) before
 returning. In Next.js, the `instrumentation.ts` above covers it.
 
-## Custom levels and categories
+## Source maps
+
+After the build, give the bundles and their maps debug ids, then upload the
+maps with Sentry's CLI:
+
+```sh
+npx @sentry/cli sourcemaps inject ./dist
+
+SENTRY_URL=https://statoss.com \
+SENTRY_AUTH_TOKEN=<a StatOSS API key with write access> \
+npx @sentry/cli sourcemaps upload --org statoss --project <app slug> ./dist
+```
+
+Adding `--release <release>` to the upload is optional. Deploy the bundles as
+`inject` left them: the SDK reads their debug ids and sends them with each
+event. Frames are then shown as source and grouped by their source names.
+
+## Your own levels, categories and fields
 
 Sentry has five levels: `fatal`, `error`, `warning`, `info` and `debug`.
-StatOSS lets you use your own words as well, and adds a category. Both are
-sent as tags next to the nearest Sentry level, so Sentry and any Sentry-based
-tool still read the event normally.
+StatOSS adds levels of your own, categories and fields. They travel as tags
+next to the nearest Sentry level, so Sentry and any Sentry-based tool still
+read the event normally.
+
+Declare them with `defineSchema` and give the schema to `init`. The capture
+functions `init` returns take only the schema's names, so a wrong one fails
+to compile.
 
 ```ts
-StatOSS.init({
-  dsn: "...",
+import * as StatOSS from "@statoss/sdk";
+
+export const schema = StatOSS.defineSchema({
   levels: {
-    "payment-failed": "error",
+    "payment-failed": { like: "error", label: "Payment failed" },
     "slow-query": "warning",
   },
+  categories: {
+    billing: { label: "Billing", color: "plum" },
+    auth: {},
+  },
+  fields: {
+    route: { label: "Route", filterable: true },
+    duration_ms: { type: "number", unit: "ms", label: "Duration" },
+  },
+});
+
+const statoss = StatOSS.init({ dsn: process.env.STATOSS_DSN, schema });
+
+statoss.captureException(error, {
+  level: "payment-failed",
+  category: "billing",
+  fields: { route: "/pay" },
+});
+// level "error", tags { "statoss.level": "payment-failed",
+//   "statoss.category": "billing", route: "/pay" }
+
+statoss.captureMessage("Search took 2.4 s", {
+  level: "slow-query",
+  fields: { duration_ms: 2400 },
+});
+
+// @ts-expect-error: not a level of this schema
+statoss.captureException(error, { level: "payment-faild" });
+```
+
+- A level ranks like `fatal`, `error`, `warning`, `info`, `debug` or
+  `trace`: give that alone, or `like` with an optional `severity` (1 to 24,
+  inside its range), `label` and `color`. It is sent as the nearest Sentry
+  level (`trace` as `debug`; `error` when none is given).
+- A category takes an optional `label`, `color`, `owner` (a team member's
+  email) and `hidden`.
+- A field is a tag key, with an optional `label`, `type` (`text` or
+  `number`), `unit` and `filterable`. Field values are strings, numbers or
+  booleans.
+- Categories and fields can also be lists of names.
+- `rules` set a level or a category for events that match, such as
+  `{ subject: "logger", value: "payments", category: "billing" }`. They name
+  the schema's own levels and categories.
+- Colours: `crimson`, `red`, `orange`, `amber`, `yellow`, `green`, `aqua`,
+  `teal`, `blue`, `violet`, `indigo`, `magenta`, `plum` and `grey`.
+- Names: a level is 1 to 32 characters and a category 1 to 64, of lowercase
+  letters, digits, dots, dashes and underscores. A field is any tag key not
+  starting `statoss.`.
+
+`defineSchema` refuses a wrong name, range, severity, colour or setting at
+compile time (TypeScript 5.0 or later). It returns the schema as given:
+plain data in the shape StatOSS's schema API takes. A function of yours
+that hands a schema to `init` types it as
+`<const S extends SchemaSpec & CheckSchema<S>>(schema: S)`.
+
+### Without a schema
+
+The module-level functions take any level or category name, and `levels` in
+`init` maps your names to Sentry levels:
+
+```ts
+StatOSS.init({
+  dsn: "...",
+  levels: { "payment-failed": "error", "slow-query": "warning" },
 });
 
 StatOSS.captureMessage("Card declined", "payment-failed");
@@ -278,11 +363,10 @@ StatOSS.captureException(error, {
 // level "warning", tags { "statoss.level": "slow-query", "statoss.category": "db.postgres" }
 ```
 
-- `level` takes a Sentry level or any name of your own. A name that is not in
-  `levels` is sent as `error`.
-- `category` sets the `statoss.category` tag.
-- Names are 1 to 64 characters of lowercase letters, digits, dots, dashes and
-  underscores. Others are ignored; with `debug: true` the SDK logs each one.
+- A name in neither `levels` nor the schema is sent as `error`. Given both,
+  `levels` wins.
+- Names the SDK cannot send are ignored; with `debug: true` it logs each
+  one.
 - StatOSS filters and groups on these tags like any other.
 
 ## What is captured
@@ -339,7 +423,8 @@ await StatOSS.withScope(async (scope) => {
 ## API
 
 ```ts
-init(options): void
+init(options): handle                                // handle.captureException, captureMessage, captureEvent
+defineSchema(schema): schema                         // the schema as given, its names as types
 captureException(error, context?): string            // returns the event id
 captureMessage(message, levelOrContext?): string
 captureEvent(event, context?): string
@@ -357,8 +442,9 @@ scope.setUser, setTag, setTags, setExtra, setExtras, setContext, setLevel,
 scope.captureException, captureMessage, captureEvent // with this scope
 ```
 
-`context` is `{ level, tags, extra, contexts, user, fingerprint, category }`.
-It wins over the scope for that one event.
+`context` is `{ level, tags, extra, contexts, user, fingerprint, category }`,
+and on the handle `init` returns also `fields`. It wins over the scope for
+that one event.
 
 ### Options
 
@@ -375,6 +461,7 @@ It wins over the scope for that one event.
 | `sendDefaultPii`   | `false`        | Record the sender's IP address                         |
 | `tags`             |                | Tags on every event                                    |
 | `initialScope`     |                | `{ tags, extra, contexts, user, level, fingerprint }`  |
+| `schema`           |                | From `defineSchema`: your levels, categories, fields   |
 | `levels`           |                | Your level names and the Sentry level each is sent as  |
 | `integrations`     | all on         | See above                                              |
 | `enabled`          | `true`         |                                                        |

package/dist/cjs/client.d.ts

@@ -2,6 +2,10 @@ import { type Logger } from "./logger.js";
 import { type RuntimeInfo } from "./runtime.js";
 import { type Scope } from "./scope.js";
 import type { Breadcrumb, BreadcrumbHint, CaptureContext, Event, InitOptions } from "./types.js";
+/** init's options as the client reads them: init may pass a schema. */
+export type ClientOptions = InitOptions & {
+    schema?: unknown;
+};
 export declare class Client {
     readonly logger: Logger;
     readonly runtime: RuntimeInfo;
@@ -20,7 +24,7 @@ export declare class Client {
     private reportTimer?;
     private previousSignature?;
     private closed;
-    constructor(options: InitOptions);
+    constructor(options: ClientOptions);
     /** Installs the integrations that apply to this runtime. */
     setup(): void;
     captureException(error: unknown, context: CaptureContext | undefined, scope: Scope): string;
@@ -44,7 +48,10 @@ export declare class Client {
     /** Merges scope, context and options into the event, in Sentry's field order. */
     private prepare;
     private process;
-    /** Makes what beforeSend handed back valid again: a Sentry level, string tags, a sane size. */
+    /**
+     * Makes what beforeSend handed back valid again (a Sentry level, string
+     * tags, a sane size) and names the debug ids of the files its frames ran in.
+     */
     private finish;
     private send;
 }

package/dist/cjs/client.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Client = void 0;
+const debug_ids_js_1 = require("./debug-ids.js");
 const dsn_js_1 = require("./dsn.js");
 const envelope_js_1 = require("./envelope.js");
 const event_js_1 = require("./event.js");
@@ -13,6 +14,7 @@ const handlers_js_1 = require("./integrations/handlers.js");
 const levels_js_1 = require("./levels.js");
 const logger_js_1 = require("./logger.js");
 const runtime_js_1 = require("./runtime.js");
+const schema_js_1 = require("./schema.js");
 const scope_js_1 = require("./scope.js");
 const transport_js_1 = require("./transport.js");
 const utils_js_1 = require("./utils.js");
@@ -53,6 +55,32 @@ function cleanTags(tags) {
     }
     return out;
 }
+/** A capture's fields, as tags. Keys starting statoss. are not fields. */
+function fieldTags(fields, logger) {
+    const out = {};
+    if (fields === undefined || fields === null)
+        return out;
+    if (!(0, utils_js_1.isObject)(fields) || Array.isArray(fields)) {
+        logger.warn('Ignored `fields`: it should be an object such as { route: "/pay" }.');
+        return out;
+    }
+    for (const [key, value] of Object.entries(fields)) {
+        if (value === undefined || value === null)
+            continue;
+        if (key === "" || key.startsWith("statoss.")) {
+            logger.warn(`Ignored field "${key}": fields are not empty and do not start statoss.`);
+        }
+        else if (typeof value === "string" ||
+            typeof value === "number" ||
+            typeof value === "boolean") {
+            out[key] = value;
+        }
+        else {
+            logger.warn(`Ignored field "${key}": its value should be a string, number or boolean.`);
+        }
+    }
+    return out;
+}
 function cleanContexts(contexts) {
     const out = {};
     for (const [name, value] of Object.entries(contexts)) {
@@ -102,7 +130,11 @@ class Client {
         this.options = options;
         this.logger = (0, logger_js_1.makeLogger)(options.debug === true);
         this.runtime = (0, runtime_js_1.describeRuntime)();
-        this.levels = (0, levels_js_1.readLevels)(options.levels, this.logger);
+        // What `levels` says wins over the schema.
+        this.levels = {
+            ...(0, schema_js_1.readSchema)(options.schema, this.logger),
+            ...(0, levels_js_1.readLevels)(options.levels, this.logger),
+        };
         const rate = options.sampleRate;
         if (rate !== undefined &&
             !(typeof rate === "number" && rate >= 0 && rate <= 1)) {
@@ -328,6 +360,7 @@ class Client {
         const tags = {
             ...scope._tags,
             ...ctx.tags,
+            ...fieldTags(ctx.fields, this.logger),
             ...base.tags,
         };
         if (choice.custom)
@@ -434,7 +467,10 @@ class Client {
         }
         this.send(this.finish(final));
     }
-    /** Makes what beforeSend handed back valid again: a Sentry level, string tags, a sane size. */
+    /**
+     * Makes what beforeSend handed back valid again (a Sentry level, string
+     * tags, a sane size) and names the debug ids of the files its frames ran in.
+     */
     finish(event) {
         if (!(0, levels_js_1.isSentryLevel)(event.level)) {
             const choice = (0, levels_js_1.chooseLevel)([event.level], this.levels, "error", this.logger);
@@ -444,6 +480,7 @@ class Client {
         }
         if ((0, utils_js_1.isObject)(event.tags))
             event.tags = cleanTags(event.tags);
+        (0, debug_ids_js_1.addDebugImages)(event);
         const size = () => (0, utils_js_1.safely)(() => JSON.stringify(event).length, 0) ?? 0;
         if (size() > MAX_EVENT_CHARS) {
             this.logger.warn("The event is over 1 MB; sending it without breadcrumbs and extra.");

package/dist/cjs/debug-ids.d.ts

@@ -0,0 +1,16 @@
+import type { Event } from "./types.js";
+/**
+ * Debug ids by the abs_path of the bundle they belong to, as Sentry's
+ * getFilenameToDebugIdMap reads them. `sentry-cli sourcemaps inject` and
+ * Sentry's bundler plugins put a snippet in each bundle that sets
+ * `globalThis._sentryDebugIds[new Error().stack] = "<debug id>"`, so the
+ * newest frame of each key ran in that bundle. Read again only when the
+ * number of entries changes (or the object is replaced).
+ */
+export declare function debugIdsByFile(): ReadonlyMap<string, string>;
+/**
+ * Adds `{ type: "sourcemap", code_file, debug_id }` to event.debug_meta.images
+ * for each file in the event's frames that has a debug id, after the images
+ * already there, so the server can map those frames to source. Never throws.
+ */
+export declare function addDebugImages(event: Event): void;

package/dist/cjs/debug-ids.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debugIdsByFile = debugIdsByFile;
+exports.addDebugImages = addDebugImages;
+const stack_js_1 = require("./stack.js");
+const utils_js_1 = require("./utils.js");
+const NONE = new Map();
+// The file each stack string names, so each is parsed once.
+const fileOfStack = new Map();
+let lastIds;
+let lastCount = -1;
+let lastMap = NONE;
+/**
+ * Debug ids by the abs_path of the bundle they belong to, as Sentry's
+ * getFilenameToDebugIdMap reads them. `sentry-cli sourcemaps inject` and
+ * Sentry's bundler plugins put a snippet in each bundle that sets
+ * `globalThis._sentryDebugIds[new Error().stack] = "<debug id>"`, so the
+ * newest frame of each key ran in that bundle. Read again only when the
+ * number of entries changes (or the object is replaced).
+ */
+function debugIdsByFile() {
+    const ids = globalThis._sentryDebugIds;
+    if (!(0, utils_js_1.isObject)(ids) || Array.isArray(ids))
+        return NONE;
+    const keys = Object.keys(ids);
+    if (ids === lastIds && keys.length === lastCount)
+        return lastMap;
+    const map = new Map();
+    for (const key of keys) {
+        const id = ids[key];
+        if (typeof id !== "string" || id === "")
+            continue;
+        if (!fileOfStack.has(key))
+            fileOfStack.set(key, newestFile(key));
+        const file = fileOfStack.get(key);
+        if (file)
+            map.set(file, id);
+    }
+    lastIds = ids;
+    lastCount = keys.length;
+    lastMap = map;
+    return map;
+}
+// As Sentry does: walking from the newest frame, the first that names a file.
+function newestFile(stack) {
+    const frames = (0, stack_js_1.parseStack)(stack);
+    for (let i = frames.length - 1; i >= 0; i--) {
+        const file = frames[i].abs_path;
+        if (file)
+            return file;
+    }
+    return undefined;
+}
+// Sentry's schema allows { values: [...] } or a bare list.
+function valuesOf(value) {
+    if (Array.isArray(value))
+        return value;
+    if ((0, utils_js_1.isObject)(value) && Array.isArray(value.values))
+        return value.values;
+    return [];
+}
+/** The abs_path of every frame in the event's exceptions and threads. */
+function framePaths(event) {
+    const paths = new Set();
+    const holders = [...valuesOf(event.exception), ...valuesOf(event.threads)];
+    for (const holder of holders) {
+        if (!(0, utils_js_1.isObject)(holder) || !(0, utils_js_1.isObject)(holder.stacktrace))
+            continue;
+        const frames = holder.stacktrace.frames;
+        if (!Array.isArray(frames))
+            continue;
+        for (const frame of frames) {
+            if ((0, utils_js_1.isObject)(frame) && typeof frame.abs_path === "string")
+                paths.add(frame.abs_path);
+        }
+    }
+    return paths;
+}
+/**
+ * Adds `{ type: "sourcemap", code_file, debug_id }` to event.debug_meta.images
+ * for each file in the event's frames that has a debug id, after the images
+ * already there, so the server can map those frames to source. Never throws.
+ */
+function addDebugImages(event) {
+    try {
+        const ids = debugIdsByFile();
+        if (!ids.size)
+            return;
+        const meta = (0, utils_js_1.isObject)(event.debug_meta)
+            ? event.debug_meta
+            : {};
+        const images = Array.isArray(meta.images)
+            ? [...meta.images]
+            : [];
+        const named = new Set();
+        for (const image of images) {
+            if ((0, utils_js_1.isObject)(image) && image.type === "sourcemap")
+                named.add(image.code_file);
+        }
+        const before = images.length;
+        for (const path of framePaths(event)) {
+            const id = ids.get(path);
+            if (id !== undefined && !named.has(path))
+                images.push({ type: "sourcemap", code_file: path, debug_id: id });
+        }
+        if (images.length > before)
+            event.debug_meta = { ...meta, images: images };
+    }
+    catch {
+        // A malformed _sentryDebugIds or event costs the images, nothing more.
+    }
+}

package/dist/cjs/index.d.ts

@@ -1,14 +1,23 @@
+import type { CheckSchema, Handle, SchemaSpec } from "./schema.js";
 import type { Breadcrumb, CaptureContext, Event, InitOptions, Level, Primitive, User } from "./types.js";
 export { withScope } from "./hub.js";
+export { defineSchema } from "./schema.js";
+export type { CategoryOf, CategorySettings, CheckSchema, FieldOf, FieldSettings, FieldType, FieldValue, Handle, LevelOf, LevelSettings, Like, RuleMatch, RuleSubject, SchemaColor, SchemaContext, SchemaRule, SchemaSpec, Severity, } from "./schema.js";
 export type { Scope } from "./scope.js";
 export { SDK_NAME, SDK_VERSION } from "./version.js";
-export type { Breadcrumb, BreadcrumbHint, CaptureContext, Event, EventHint, Exception, InitOptions, IntegrationToggles, Level, Mechanism, Primitive, RequestInfo, ScopeData, SdkInfo, SentryLevel, StackFrame, Transport, TransportRequest, TransportResponse, User, } from "./types.js";
+export type { Breadcrumb, BreadcrumbHint, CaptureContext, DebugImage, Event, EventHint, Exception, InitOptions, IntegrationToggles, Level, Mechanism, Primitive, RequestInfo, ScopeData, SdkInfo, SentryLevel, StackFrame, Transport, TransportRequest, TransportResponse, User, } from "./types.js";
 /**
  * Starts the SDK. Call it once, as early as you can. Calling it again replaces
  * the earlier setup. Without a valid DSN, or with enabled: false, nothing is
  * sent and nothing is patched.
+ *
+ * With a `schema` from defineSchema, its levels are sent as the Sentry level
+ * each ranks like, and the capture functions it returns take only the
+ * schema's levels, categories and fields.
  */
-export declare function init(options?: InitOptions): void;
+export declare function init<const S extends SchemaSpec & CheckSchema<S> = SchemaSpec>(options?: InitOptions & {
+    schema?: S;
+}): Handle<S>;
 /** Sends an error (or anything thrown). Returns the event id. */
 export declare function captureException(error: unknown, context?: CaptureContext): string;
 /**

package/dist/cjs/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SDK_VERSION = exports.SDK_NAME = exports.withScope = void 0;
+exports.SDK_VERSION = exports.SDK_NAME = exports.defineSchema = exports.withScope = void 0;
 exports.init = init;
 exports.captureException = captureException;
 exports.captureMessage = captureMessage;
@@ -19,14 +19,11 @@ const hub_js_1 = require("./hub.js");
 const utils_js_1 = require("./utils.js");
 var hub_js_2 = require("./hub.js");
 Object.defineProperty(exports, "withScope", { enumerable: true, get: function () { return hub_js_2.withScope; } });
+var schema_js_1 = require("./schema.js");
+Object.defineProperty(exports, "defineSchema", { enumerable: true, get: function () { return schema_js_1.defineSchema; } });
 var version_js_1 = require("./version.js");
 Object.defineProperty(exports, "SDK_NAME", { enumerable: true, get: function () { return version_js_1.SDK_NAME; } });
 Object.defineProperty(exports, "SDK_VERSION", { enumerable: true, get: function () { return version_js_1.SDK_VERSION; } });
-/**
- * Starts the SDK. Call it once, as early as you can. Calling it again replaces
- * the earlier setup. Without a valid DSN, or with enabled: false, nothing is
- * sent and nothing is patched.
- */
 function init(options = {}) {
     try {
         const carrier = (0, hub_js_1.getCarrier)();
@@ -45,6 +42,7 @@ function init(options = {}) {
             (0, utils_js_1.safely)(() => console.error("[StatOSS] init failed:", error));
         }
     }
+    return HANDLE;
 }
 /** Sends an error (or anything thrown). Returns the event id. */
 function captureException(error, context) {
@@ -61,6 +59,13 @@ function captureMessage(message, levelOrContext) {
 function captureEvent(event, context) {
     return (0, hub_js_1.captureWith)(undefined, (client, scope) => client.captureEvent(event, context, scope));
 }
+// What init returns: the same functions, typed by the schema. The client
+// reads a context's fields whichever function it came through.
+const HANDLE = Object.freeze({
+    captureException,
+    captureMessage,
+    captureEvent,
+});
 /** Pass null to forget the user. */
 function setUser(user) {
     (0, utils_js_1.safely)(() => (0, hub_js_1.getCurrentScope)().setUser(user));

package/dist/cjs/levels.d.ts

@@ -1,10 +1,13 @@
 import type { Logger } from "./logger.js";
 import type { SentryLevel } from "./types.js";
 export declare const SENTRY_LEVELS: readonly SentryLevel[];
+export declare const LEVEL_RULE = "use 1 to 32 lowercase letters, digits, dots, dashes or underscores";
+export declare const CATEGORY_RULE = "use 1 to 64 lowercase letters, digits, dots, dashes or underscores";
 export declare const LEVEL_TAG = "statoss.level";
 export declare const CATEGORY_TAG = "statoss.category";
 export declare function isSentryLevel(value: unknown): value is SentryLevel;
-export declare function isValidName(value: unknown): value is string;
+export declare function isLevelName(value: unknown): value is string;
+export declare function isCategoryName(value: unknown): value is string;
 /** Keeps the entries of init's `levels` that are usable, logging the rest in debug mode. */
 export declare function readLevels(input: unknown, logger: Logger): Record<string, SentryLevel>;
 export interface LevelChoice {

package/dist/cjs/levels.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CATEGORY_TAG = exports.LEVEL_TAG = exports.SENTRY_LEVELS = void 0;
+exports.CATEGORY_TAG = exports.LEVEL_TAG = exports.CATEGORY_RULE = exports.LEVEL_RULE = exports.SENTRY_LEVELS = void 0;
 exports.isSentryLevel = isSentryLevel;
-exports.isValidName = isValidName;
+exports.isLevelName = isLevelName;
+exports.isCategoryName = isCategoryName;
 exports.readLevels = readLevels;
 exports.chooseLevel = chooseLevel;
 exports.readCategory = readCategory;
@@ -14,16 +15,26 @@ exports.SENTRY_LEVELS = [
     "info",
     "debug",
 ];
-/** Custom level and category names: what the server accepts as tag values to filter on. */
-const NAME_RE = /^[a-z0-9._-]{1,64}$/;
+/**
+ * Names of your own: lowercase letters, digits, dots, dashes and
+ * underscores. A level is at most 32 characters, as the server keeps it; a
+ * category at most 64.
+ */
+const LEVEL_RE = /^[a-z0-9._-]{1,32}$/;
+const CATEGORY_RE = /^[a-z0-9._-]{1,64}$/;
+exports.LEVEL_RULE = "use 1 to 32 lowercase letters, digits, dots, dashes or underscores";
+exports.CATEGORY_RULE = "use 1 to 64 lowercase letters, digits, dots, dashes or underscores";
 exports.LEVEL_TAG = "statoss.level";
 exports.CATEGORY_TAG = "statoss.category";
 function isSentryLevel(value) {
     return (typeof value === "string" &&
         exports.SENTRY_LEVELS.includes(value));
 }
-function isValidName(value) {
-    return typeof value === "string" && NAME_RE.test(value);
+function isLevelName(value) {
+    return typeof value === "string" && LEVEL_RE.test(value);
+}
+function isCategoryName(value) {
+    return typeof value === "string" && CATEGORY_RE.test(value);
 }
 /** Keeps the entries of init's `levels` that are usable, logging the rest in debug mode. */
 function readLevels(input, logger) {
@@ -38,8 +49,8 @@ function readLevels(input, logger) {
         if (isSentryLevel(name)) {
             logger.warn(`Ignored level "${name}" in \`levels\`: it is already a Sentry level.`);
         }
-        else if (!isValidName(name)) {
-            logger.warn(`Ignored level "${name}" in \`levels\`: use 1 to 64 lowercase letters, digits, dots, dashes or underscores.`);
+        else if (!isLevelName(name)) {
+            logger.warn(`Ignored level "${name}" in \`levels\`: ${exports.LEVEL_RULE}.`);
         }
         else if (!isSentryLevel(level)) {
             logger.warn(`Ignored level "${name}" in \`levels\`: map it to fatal, error, warning, info or debug.`);
@@ -60,18 +71,18 @@ function chooseLevel(candidates, levels, fallback, logger) {
             continue;
         if (isSentryLevel(candidate))
             return { level: candidate };
-        if (isValidName(candidate)) {
+        if (isLevelName(candidate)) {
             return { level: levels[candidate] ?? "error", custom: candidate };
         }
-        logger.warn(`Ignored level "${(0, utils_js_1.safeString)(candidate)}": use a Sentry level or 1 to 64 lowercase letters, digits, dots, dashes or underscores.`);
+        logger.warn(`Ignored level "${(0, utils_js_1.safeString)(candidate)}": use a Sentry level or 1 to 32 lowercase letters, digits, dots, dashes or underscores.`);
     }
     return { level: fallback };
 }
 function readCategory(value, logger) {
     if (value === undefined || value === null)
         return undefined;
-    if (isValidName(value))
+    if (isCategoryName(value))
         return value;
-    logger.warn(`Ignored category "${(0, utils_js_1.safeString)(value)}": use 1 to 64 lowercase letters, digits, dots, dashes or underscores.`);
+    logger.warn(`Ignored category "${(0, utils_js_1.safeString)(value)}": ${exports.CATEGORY_RULE}.`);
     return undefined;
 }