@statoss/sdk 0.2.0 → 0.4.0

package/dist/cjs/envelope.js

@@ -1,12 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOG_CONTENT_TYPE = void 0;
 exports.eventEnvelope = eventEnvelope;
 exports.clientReportEnvelope = clientReportEnvelope;
+exports.logEnvelope = logEnvelope;
 exports.itemCategory = itemCategory;
+exports.itemQuantity = itemQuantity;
+exports.isLogEnvelope = isLogEnvelope;
 exports.serializeEnvelope = serializeEnvelope;
 const dsn_js_1 = require("./dsn.js");
 const utils_js_1 = require("./utils.js");
 const version_js_1 = require("./version.js");
+exports.LOG_CONTENT_TYPE = "application/vnd.sentry.items.log+json";
 function sdkHeader() {
     return { name: version_js_1.SDK_NAME, version: version_js_1.SDK_VERSION };
 }
@@ -31,9 +36,44 @@ function clientReportEnvelope(discarded, dsn, timestamp = Date.now() / 1000) {
         [[{ type: "client_report" }, { timestamp, discarded_events: discarded }]],
     ];
 }
+/** Log lines in one envelope, as Sentry's logger sends them. */
+function logEnvelope(logs, dsn) {
+    return [
+        {
+            sent_at: new Date().toISOString(),
+            dsn: (0, dsn_js_1.dsnToString)(dsn),
+            sdk: sdkHeader(),
+        },
+        [
+            [
+                {
+                    type: "log",
+                    item_count: logs.length,
+                    content_type: exports.LOG_CONTENT_TYPE,
+                },
+                { version: 2, items: logs },
+            ],
+        ],
+    ];
+}
 /** Sentry's rate-limit category for an envelope item. */
 function itemCategory(item) {
-    return item[0].type === "event" ? "error" : "internal";
+    switch (item[0].type) {
+        case "event":
+            return "error";
+        case "log":
+            return "log_item";
+        default:
+            return "internal";
+    }
+}
+/** How many things an item holds, as client reports count them. */
+function itemQuantity(item) {
+    return item[0].type === "log" ? item[0].item_count : 1;
+}
+/** True for an envelope of log lines. */
+function isLogEnvelope(envelope) {
+    return envelope[1].some((item) => item[0].type === "log");
 }
 function stringify(payload) {
     try {

package/dist/cjs/index.d.ts

@@ -1,14 +1,25 @@
+import { type AppLogger } from "./logs.js";
+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 type { AppLogger, Log, LogAttributes, LogAttributeValue, LogLevel, LogLevelOf, LogMessage, SerializedLog, } from "./logs.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, 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.
+ * sent and nothing is patched. With `logs: true`, `logger`'s lines are sent.
+ *
+ * With a `schema` from defineSchema, its levels are sent as the Sentry level
+ * each ranks like, and the capture functions and logger 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;
 /**
@@ -18,6 +29,12 @@ export declare function captureException(error: unknown, context?: CaptureContex
 export declare function captureMessage(message: string, levelOrContext?: Level | CaptureContext): string;
 /** Sends an event you built in Sentry's schema. Returns the event id. */
 export declare function captureEvent(event: Event, context?: CaptureContext): string;
+/**
+ * Log lines, sent when init has `logs: true`: logger.info("Paid", { orderId: 7 }),
+ * logger.warn(logger.fmt`Took ${ms} ms`), logger.log("payment-failed", "Card declined").
+ * Lines go out in batches; flush() and close() send what waits.
+ */
+export declare const logger: AppLogger;
 /** Pass null to forget the user. */
 export declare function setUser(user: User | null): void;
 export declare function setTag(key: string, value: Primitive): void;

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.logger = exports.SDK_VERSION = exports.SDK_NAME = exports.defineSchema = exports.withScope = void 0;
 exports.init = init;
 exports.captureException = captureException;
 exports.captureMessage = captureMessage;
@@ -16,17 +16,15 @@ exports.close = close;
 exports.lastEventId = lastEventId;
 const client_js_1 = require("./client.js");
 const hub_js_1 = require("./hub.js");
+const logs_js_1 = require("./logs.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 +43,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 +60,20 @@ function captureMessage(message, levelOrContext) {
 function captureEvent(event, context) {
     return (0, hub_js_1.captureWith)(undefined, (client, scope) => client.captureEvent(event, context, scope));
 }
+/**
+ * Log lines, sent when init has `logs: true`: logger.info("Paid", { orderId: 7 }),
+ * logger.warn(logger.fmt`Took ${ms} ms`), logger.log("payment-failed", "Card declined").
+ * Lines go out in batches; flush() and close() send what waits.
+ */
+exports.logger = (0, logs_js_1.makeAppLogger)((level, message, attributes) => (0, utils_js_1.safely)(() => (0, hub_js_1.getCarrier)().client?.captureLog(level, message, attributes, (0, hub_js_1.getCurrentScope)())));
+// 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,
+    logger: exports.logger,
+});
 /** 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;
 }

package/dist/cjs/logs.d.ts

@@ -0,0 +1,133 @@
+import type { Logger } from "./logger.js";
+import type { LevelOf, SchemaSpec } from "./schema.js";
+import type { SentryLevel } from "./types.js";
+/**
+ * Log lines, as Sentry's logger sends them: `log` items in envelopes, each
+ * line with a level, a body and typed attributes
+ * (https://develop.sentry.dev/sdk/telemetry/logs/).
+ */
+/** The levels of a log line: OpenTelemetry's six ranges, as Sentry's logger names them. */
+export type LogLevel = "trace" | "debug" | "info" | "warn" | "error" | "fatal";
+export declare const LOG_LEVELS: readonly LogLevel[];
+/** What intake keeps of a line (docs/logs.md, In), in UTF-8 bytes: a body, and an attribute's value. */
+export declare const MAX_BODY_BYTES: number;
+export declare const MAX_ATTRIBUTE_BYTES: number;
+/** A cut body's size in bytes before the cut, as intake records it. */
+export declare const TRUNCATED = "statoss.truncated";
+/** Each level's severity number: the start of its OpenTelemetry range. */
+export declare const LOG_SEVERITY: Readonly<Record<LogLevel, number>>;
+export declare function isLogLevel(value: unknown): value is LogLevel;
+/** The level a range (a schema's `like`) or a Sentry level is logged at. */
+export declare function logLevelOf(range: string): LogLevel | undefined;
+/** The range a severity number falls in. */
+export declare function rangeOfSeverity(severity: number): LogLevel;
+/** A message made by `logger.fmt`: the text, and the template and values it came from. */
+export interface LogMessage {
+    /** The message, its values filled in. */
+    readonly text: string;
+    /** The template, each value written %s, as Sentry's logger writes it. */
+    readonly template: string;
+    readonly values: readonly unknown[];
+    toString(): string;
+}
+/**
+ * A message with parameters: logger.info(logger.fmt`Paid ${amount} for ${order}`).
+ * The line's body is the text; the template and each value go along as
+ * the attributes sentry.message.template and sentry.message.parameter.<n>.
+ */
+export declare function fmt(strings: TemplateStringsArray, ...values: unknown[]): LogMessage;
+export declare function isLogMessage(value: unknown): value is LogMessage;
+/** A line's attributes: strings, numbers and booleans are sent as they are, anything else as JSON. */
+export type LogAttributes = Record<string, unknown>;
+/** A log line before it is sent, as beforeSendLog sees it. */
+export interface Log {
+    level: LogLevel;
+    /** The message, with its values filled in. */
+    message: string;
+    attributes: LogAttributes;
+    /** 1 to 24, inside the level's range. */
+    severityNumber: number;
+    /** Seconds since the epoch, with fractions. */
+    timestamp: number;
+}
+export type LogAttributeValue = {
+    value: string;
+    type: "string";
+} | {
+    value: number;
+    type: "integer";
+} | {
+    value: number;
+    type: "double";
+} | {
+    value: boolean;
+    type: "boolean";
+};
+/** A log line as an envelope's log item holds it. */
+export interface SerializedLog {
+    timestamp: number;
+    level: LogLevel;
+    body: string;
+    /** 32 lower-case hex digits; Sentry's Relay drops a line without one. */
+    trace_id: string;
+    severity_number: number;
+    attributes: Record<string, LogAttributeValue>;
+}
+/** An attribute's value as Sentry types it; undefined and null are left out. */
+export declare function serializeAttribute(value: unknown): LogAttributeValue | undefined;
+/** A string's length in UTF-8 bytes. */
+export declare function utf8Length(s: string): number;
+/**
+ * A string cut to at most `max` UTF-8 bytes, the cut marked "...", as
+ * intake's cut writes it (intake/normalize.ts), never inside a character.
+ */
+export declare function cutBytes(s: string, max: number): string;
+/**
+ * A body past 64 KiB is cut there, with its size in bytes as
+ * statoss.truncated, as intake cuts it and records it: one huge line must
+ * not take the batch it is sent in down with it.
+ */
+export declare function cutBody(body: string, attributes: Record<string, LogAttributeValue>): string;
+/** The message, or a value in it, as text: objects as JSON. */
+export declare function bodyOf(message: unknown): string;
+/** A level of the app's own, as a line is logged at it. */
+export interface OwnLogLevel {
+    level: LogLevel;
+    severity: number;
+}
+export interface LogLevelChoice {
+    level: LogLevel;
+    severity: number;
+    /** The app's own level, when the line names one. */
+    custom?: string;
+}
+/**
+ * The level a line is logged at. One of the six (or a Sentry level) is
+ * itself; an app's own level is its range's, with its severity and its
+ * name for statoss.level; a name nobody declared ranks as error, as an
+ * event's does. Anything else is logged as info.
+ */
+export declare function chooseLogLevel(level: unknown, own: Record<string, OwnLogLevel>, logger: Logger): LogLevelChoice;
+/** The ranges of init's `levels`: a Sentry level each. */
+export declare function ownLevelsFromSentry(levels: Record<string, SentryLevel>): Record<string, OwnLogLevel>;
+/** What `logger` and the handle's `logger` take as a level, typed by the schema. */
+export type LogLevelOf<S = SchemaSpec> = LogLevel | LevelOf<S>;
+/** The logger: one method per level, any level by name, and templates. */
+export interface AppLogger<S = SchemaSpec> {
+    trace(message: string | LogMessage, attributes?: LogAttributes): void;
+    debug(message: string | LogMessage, attributes?: LogAttributes): void;
+    info(message: string | LogMessage, attributes?: LogAttributes): void;
+    warn(message: string | LogMessage, attributes?: LogAttributes): void;
+    error(message: string | LogMessage, attributes?: LogAttributes): void;
+    fatal(message: string | LogMessage, attributes?: LogAttributes): void;
+    /**
+     * A line at a level by name: one of the six, a Sentry level, or one of
+     * the app's own (with a schema, only its names). An own level is sent at
+     * its range's level with the attribute statoss.level.
+     */
+    log(level: LogLevelOf<S>, message: string | LogMessage, attributes?: LogAttributes): void;
+    /** A message with parameters: logger.fmt`Paid ${amount}`. */
+    fmt(strings: TemplateStringsArray, ...values: unknown[]): LogMessage;
+}
+/** A logger that hands each line to `capture`. */
+export declare function makeAppLogger(capture: (level: unknown, message: unknown, attributes: LogAttributes | undefined) => void): AppLogger;

package/dist/cjs/logs.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOG_SEVERITY = exports.TRUNCATED = exports.MAX_ATTRIBUTE_BYTES = exports.MAX_BODY_BYTES = exports.LOG_LEVELS = void 0;
+exports.isLogLevel = isLogLevel;
+exports.logLevelOf = logLevelOf;
+exports.rangeOfSeverity = rangeOfSeverity;
+exports.fmt = fmt;
+exports.isLogMessage = isLogMessage;
+exports.serializeAttribute = serializeAttribute;
+exports.utf8Length = utf8Length;
+exports.cutBytes = cutBytes;
+exports.cutBody = cutBody;
+exports.bodyOf = bodyOf;
+exports.chooseLogLevel = chooseLogLevel;
+exports.ownLevelsFromSentry = ownLevelsFromSentry;
+exports.makeAppLogger = makeAppLogger;
+const levels_js_1 = require("./levels.js");
+const utils_js_1 = require("./utils.js");
+exports.LOG_LEVELS = [
+    "trace",
+    "debug",
+    "info",
+    "warn",
+    "error",
+    "fatal",
+];
+/** What intake keeps of a line (docs/logs.md, In), in UTF-8 bytes: a body, and an attribute's value. */
+exports.MAX_BODY_BYTES = 64 * 1024;
+exports.MAX_ATTRIBUTE_BYTES = 8 * 1024;
+/** A cut body's size in bytes before the cut, as intake records it. */
+exports.TRUNCATED = "statoss.truncated";
+/** Each level's severity number: the start of its OpenTelemetry range. */
+exports.LOG_SEVERITY = {
+    trace: 1,
+    debug: 5,
+    info: 9,
+    warn: 13,
+    error: 17,
+    fatal: 21,
+};
+function isLogLevel(value) {
+    return (typeof value === "string" &&
+        exports.LOG_LEVELS.includes(value));
+}
+/** The level a range (a schema's `like`) or a Sentry level is logged at. */
+function logLevelOf(range) {
+    if (range === "warning")
+        return "warn";
+    return isLogLevel(range) ? range : undefined;
+}
+/** The range a severity number falls in. */
+function rangeOfSeverity(severity) {
+    if (severity >= 21)
+        return "fatal";
+    if (severity >= 17)
+        return "error";
+    if (severity >= 13)
+        return "warn";
+    if (severity >= 9)
+        return "info";
+    if (severity >= 5)
+        return "debug";
+    return "trace";
+}
+/**
+ * A message with parameters: logger.info(logger.fmt`Paid ${amount} for ${order}`).
+ * The line's body is the text; the template and each value go along as
+ * the attributes sentry.message.template and sentry.message.parameter.<n>.
+ */
+function fmt(strings, ...values) {
+    const parts = Array.from(strings, (s, i) => s ?? strings.raw[i]);
+    let text = parts[0];
+    for (let i = 1; i < parts.length; i++)
+        text += `${bodyOf(values[i - 1])}${parts[i]}`;
+    return Object.freeze({
+        text,
+        template: parts.map((s) => s.replace(/%/g, "%%")).join("%s"),
+        values: Object.freeze([...values]),
+        toString: () => text,
+    });
+}
+function isLogMessage(value) {
+    return ((0, utils_js_1.isObject)(value) &&
+        typeof value.text === "string" &&
+        typeof value.template === "string" &&
+        Array.isArray(value.values));
+}
+/** An attribute's value as Sentry types it; undefined and null are left out. */
+function serializeAttribute(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value === "string")
+        return { value: cutBytes(value, exports.MAX_ATTRIBUTE_BYTES), type: "string" };
+    if (typeof value === "boolean")
+        return { value, type: "boolean" };
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            return { value: (0, utils_js_1.safeString)(value), type: "string" };
+        return Number.isInteger(value)
+            ? { value, type: "integer" }
+            : { value, type: "double" };
+    }
+    if (typeof value === "bigint") {
+        const n = Number(value);
+        return Number.isSafeInteger(n)
+            ? { value: n, type: "integer" }
+            : { value: value.toString(), type: "string" };
+    }
+    const text = value instanceof String
+        ? String(value)
+        : ((0, utils_js_1.safely)(() => JSON.stringify((0, utils_js_1.normalize)(value, 4, 1024, 100))) ??
+            (0, utils_js_1.safeString)(value));
+    return { value: cutBytes(text, exports.MAX_ATTRIBUTE_BYTES), type: "string" };
+}
+/** UTF-8 bytes of one UTF-16 unit at i, and how many units it takes. */
+function utf8At(s, i) {
+    const c = s.charCodeAt(i);
+    if (c < 0x80)
+        return [1, 1];
+    if (c < 0x800)
+        return [2, 1];
+    if (c >= 0xd800 &&
+        c <= 0xdbff &&
+        i + 1 < s.length &&
+        (s.charCodeAt(i + 1) & 0xfc00) === 0xdc00)
+        return [4, 2];
+    // A lone surrogate is written as U+FFFD, three bytes.
+    return [3, 1];
+}
+/** A string's length in UTF-8 bytes. */
+function utf8Length(s) {
+    let n = 0;
+    for (let i = 0; i < s.length;) {
+        const [bytes, units] = utf8At(s, i);
+        n += bytes;
+        i += units;
+    }
+    return n;
+}
+/**
+ * A string cut to at most `max` UTF-8 bytes, the cut marked "...", as
+ * intake's cut writes it (intake/normalize.ts), never inside a character.
+ */
+function cutBytes(s, max) {
+    if (s.length * 3 <= max || utf8Length(s) <= max)
+        return s;
+    let n = 0;
+    let i = 0;
+    while (i < s.length) {
+        const [bytes, units] = utf8At(s, i);
+        if (n + bytes > max - 3)
+            break;
+        n += bytes;
+        i += units;
+    }
+    // As intake: a lone high surrogate does not end a cut.
+    if (i > 0 && /[\ud800-\udbff]/.test(s[i - 1]))
+        i--;
+    return `${s.slice(0, i)}...`;
+}
+/**
+ * A body past 64 KiB is cut there, with its size in bytes as
+ * statoss.truncated, as intake cuts it and records it: one huge line must
+ * not take the batch it is sent in down with it.
+ */
+function cutBody(body, attributes) {
+    if (body.length * 3 <= exports.MAX_BODY_BYTES)
+        return body;
+    const size = utf8Length(body);
+    if (size <= exports.MAX_BODY_BYTES)
+        return body;
+    attributes[exports.TRUNCATED] = { value: size, type: "integer" };
+    return cutBytes(body, exports.MAX_BODY_BYTES);
+}
+/** The message, or a value in it, as text: objects as JSON. */
+function bodyOf(message) {
+    if (typeof message === "string")
+        return message;
+    if (isLogMessage(message))
+        return message.text;
+    if (message instanceof String)
+        return String(message);
+    if ((0, utils_js_1.isObject)(message) && !(message instanceof Error)) {
+        const json = (0, utils_js_1.safely)(() => JSON.stringify((0, utils_js_1.normalize)(message, 4)));
+        if (json !== undefined)
+            return json;
+    }
+    return (0, utils_js_1.safeString)(message);
+}
+/**
+ * The level a line is logged at. One of the six (or a Sentry level) is
+ * itself; an app's own level is its range's, with its severity and its
+ * name for statoss.level; a name nobody declared ranks as error, as an
+ * event's does. Anything else is logged as info.
+ */
+function chooseLogLevel(level, own, logger) {
+    if (isLogLevel(level))
+        return { level, severity: exports.LOG_SEVERITY[level] };
+    if ((0, levels_js_1.isSentryLevel)(level)) {
+        const as = logLevelOf(level) ?? "error";
+        return { level: as, severity: exports.LOG_SEVERITY[as] };
+    }
+    if ((0, levels_js_1.isLevelName)(level)) {
+        const found = own[level];
+        if (found)
+            return { ...found, custom: level };
+        logger.warn(`Level "${level}" is not in the schema or \`levels\`, so the line is logged as error.`);
+        return { level: "error", severity: exports.LOG_SEVERITY.error, custom: level };
+    }
+    logger.warn(`Logged "${(0, utils_js_1.safeString)(level)}" as info: use trace, debug, info, warn, error, fatal or a level name (${levels_js_1.LEVEL_RULE}).`);
+    return { level: "info", severity: exports.LOG_SEVERITY.info };
+}
+/** The ranges of init's `levels`: a Sentry level each. */
+function ownLevelsFromSentry(levels) {
+    const out = {};
+    for (const [name, sentAs] of Object.entries(levels)) {
+        const level = logLevelOf(sentAs) ?? "error";
+        out[name] = { level, severity: exports.LOG_SEVERITY[level] };
+    }
+    return out;
+}
+/** A logger that hands each line to `capture`. */
+function makeAppLogger(capture) {
+    const at = (level) => (message, attributes) => capture(level, message, attributes);
+    return Object.freeze({
+        trace: at("trace"),
+        debug: at("debug"),
+        info: at("info"),
+        warn: at("warn"),
+        error: at("error"),
+        fatal: at("fatal"),
+        log: (level, message, attributes) => capture(level, message, attributes),
+        fmt,
+    });
+}