@sasjs/utils 4.1.2 → 4.3.0

package/README.md

@@ -20,6 +20,7 @@ import { ServerType } from '@sasjs/utils/types'
 import { prefixMessage } from '@sasjs/utils/error'
 import { isSpecialMissing } from '@sasjs/utils/input/validators'
 import { bytesToSize } from '@sasjs/utils/utils'
+import { parseLog } from '@sasjs/utils/logs'
 ```
 
 The hash and sync helpers - `getHash`, `compareHashes`, `extractHashArray`,
@@ -29,6 +30,20 @@ folders on disk, so they are Node-only, and the barrel does not re-export them:
 bundle that imports the barrel for anything else no longer reaches `crypto`, which used to
 arrive with the whole AES/RSA/ECDSA polyfill suite behind it.
 
+`@sasjs/utils/logs` parses a SAS log: `parseLog(text)` returns every `ERROR`,
+`WARNING` and notable `NOTE` as an issue addressed by line and column, and
+`nextIssue(issues, line, direction)` walks that list for a next/previous problem
+control. It is a pair of pure functions with no imports at all, so it runs
+unchanged in Node, in a browser bundle and in an editor extension, and it lives
+on a subpath so a browser never reaches the barrel's Node dependencies.
+
+Only the notes the log-checking literature chases are reported - an
+uninitialized variable, invalid data, a W.D format too small, values converted to
+another type, repeats of BY values - because a log carries thousands of ordinary
+notes and none of them is what a reader is looking for. The list is
+`NOTE_KEYWORDS` in `src/logs/sasLog.ts`, and adding a keyword is how the scope
+grows.
+
 ## Contributors ✨
 
 Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

package/index.d.ts

@@ -3,6 +3,7 @@ export * from './file';
 export * from './formatter';
 export * from './input';
 export * from './logger';
+export * from './logs';
 export * from './sasjsCli';
 export * from './time';
 export * from './types';

package/index.js

@@ -15,6 +15,7 @@ __exportStar(require("./file"), exports);
 __exportStar(require("./formatter"), exports);
 __exportStar(require("./input"), exports);
 __exportStar(require("./logger"), exports);
+__exportStar(require("./logs"), exports);
 __exportStar(require("./sasjsCli"), exports);
 __exportStar(require("./time"), exports);
 __exportStar(require("./types"), exports);

package/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,yCAAsB;AACtB,yCAAsB;AACtB,8CAA2B;AAC3B,0CAAuB;AACvB,2CAAwB;AACxB,6CAA0B;AAC1B,yCAAsB;AACtB,0CAAuB;AACvB,0CAAuB;AACvB,gDAA6B;AAC7B,yEAAyE;AACzE,6EAA6E;AAC7E,6EAA6E;AAC7E,6EAA6E;AAC7E,4EAA4E;AAC5E,uBAAuB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,yCAAsB;AACtB,yCAAsB;AACtB,8CAA2B;AAC3B,0CAAuB;AACvB,2CAAwB;AACxB,yCAAsB;AACtB,6CAA0B;AAC1B,yCAAsB;AACtB,0CAAuB;AACvB,0CAAuB;AACvB,gDAA6B;AAC7B,yEAAyE;AACzE,6EAA6E;AAC7E,6EAA6E;AAC7E,6EAA6E;AAC7E,4EAA4E;AAC5E,uBAAuB"}

package/logs/index.d.ts

@@ -0,0 +1 @@
+export * from './sasLog';

package/logs/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./sasLog"), exports);
+//# sourceMappingURL=index.js.map

package/logs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/logs/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,2CAAwB"}

package/logs/sasLog.d.ts

@@ -0,0 +1,121 @@
+/**
+ * SAS log parsing.
+ *
+ * A SAS log is a stream of statements and messages, and only the messages
+ * matter to a reader looking for trouble: the ones SAS prints at the start of a
+ * line as `ERROR`, `WARNING` or `NOTE`. This module finds those messages and
+ * reports where they are, as line and column indexes into the text it was given,
+ * so a host can underline them without re-scanning the log and without rewriting
+ * it.
+ *
+ * What is recognised - the marker in capitals, beginning the line:
+ *
+ *   ERROR: Libref X is not assigned.
+ *   ERROR Libref Y is not assigned.
+ *   ERROR 22-322: Syntax error, expecting one of the following: ;, CANCEL,
+ *                 RUN, QUIT.
+ *   WARNING 1-322: Assuming the symbol Y was misspelled.
+ *   NOTE: Variable x is uninitialized.
+ *
+ * An error or a warning needs a colon, or a space, after the marker; `ERROR` on
+ * its own is not a message, and neither is every line that happens to begin with
+ * the word. The numeric code between the marker and the colon is SAS's own
+ * message identifier and is reported separately, so a host can group by it.
+ *
+ * NOTES are reported only when they are the ones the log-checking literature
+ * flags - see NOTE_KEYWORDS - and only in their colon form, because the notes
+ * stream is endless and the notable ones are a closed list. A coded note
+ * (`NOTE 49-169:`) is one of them and keeps its code. INFO lines are not
+ * reported at all.
+ *
+ * {@link isSasLog} answers the different question a host asks before publishing
+ * anything: whether this file is a SAS log at all. A Python log and a shell build
+ * log both write `ERROR:` at the start of a line, so the marker alone does not
+ * say so - the banner SAS prints about itself does, and so do its message codes
+ * and its padded step numbers.
+ *
+ * Lines SAS wrapped are folded into the message they belong to, so one problem
+ * is one issue rather than one issue per wrapped line, and the keyword search
+ * runs on the folded message - a note whose keyword lands on the second line is
+ * still found. Nothing indented counts as a marker, and neither does a marker in
+ * lower case: the real one starts the line, which keeps a print of a data set,
+ * or a message quoting another log, out of the results.
+ *
+ * ODS HTML logs wrap every line in markup. A tag sequence before the marker is
+ * skipped and tags are stripped from the reported message, so the same parse
+ * serves a plain log and an HTML one. The line and column indexes stay those of
+ * the text as supplied, because they are what the caller needs to address.
+ *
+ * Nothing here touches the log: the caller renders from the issue list, which is
+ * what lets one log be shown in an editor, in a browser panel and in a report
+ * from the same parse.
+ */
+/**
+ * The severities a log issue can carry. `note` is only ever a notable note - see
+ * NOTE_KEYWORDS - never an ordinary one.
+ */
+export declare type LogSeverity = 'error' | 'warning' | 'note';
+/** One ERROR, WARNING or notable NOTE in a SAS log, addressed in the text it was parsed from. */
+export interface LogIssue {
+    /** Zero-based index of the line carrying the marker. */
+    line: number;
+    /** Zero-based index of the last line SAS wrapped into this message. */
+    endLine: number;
+    /** Zero-based column where the marker starts on `line`. */
+    column: number;
+    /** Zero-based column one past the end of `line`, for underlining it. */
+    endColumn: number;
+    /** The marker that introduced the issue. */
+    severity: LogSeverity;
+    /** SAS's message identifier, e.g. `22-322` for `ERROR 22-322:`. */
+    code?: string;
+    /** The message text, with wrapped lines joined and markup stripped. */
+    message: string;
+}
+/** Direction of travel for {@link nextIssue}. */
+export declare type IssueDirection = 'next' | 'previous';
+/**
+ * Whether a text is a SAS log rather than somebody else's log file.
+ *
+ * A marker alone does not say so: Python's logging writes `ERROR:root:boom` and
+ * a shell build log writes `ERROR: Command failed with exit code 1`, both at the
+ * start of a line. Nor does the word SAS - build logs of this estate's own
+ * repositories mention it in prose - so the test is SAS's own vocabulary: the
+ * banner it prints about itself, its message codes, and its padded step numbers.
+ * Each of those is written by SAS and by nothing else.
+ *
+ * This is a heuristic, and one way only: a true answer means SAS wrote the text,
+ * while a false answer does not prove it did not - a trimmed excerpt of a log,
+ * pasted with only its `ERROR:` lines, carries none of the three and reads as
+ * somebody else's. A host that publishes diagnostics should therefore treat false
+ * as "not obviously SAS" rather than "not SAS".
+ *
+ * Counting marker lines instead was considered and rejected: two `ERROR:` lines is
+ * what a Python log is made of, so it would readmit exactly the files this
+ * predicate exists to keep out.
+ *
+ * The check is deliberately cheap and runs before a host publishes anything, so
+ * a `.log` from another tool is left alone.
+ */
+export declare const isSasLog: (text: string) => boolean;
+/** Whether a note's message is one of the notable ones. */
+export declare const isNotableNote: (message: string) => boolean;
+/**
+ * Finds every ERROR and WARNING in a SAS log, and every notable note.
+ *
+ * The issue list is in log order. `line` and `column` address the text as
+ * supplied, so a caller can offset a decoration or a diagnostic by them
+ * directly. A host that wants errors only filters on `severity`; nothing is
+ * behind an option, because a notable note is worth reporting wherever the log
+ * is shown.
+ */
+export declare const parseLog: (text: string) => LogIssue[];
+/**
+ * The issue after (or before) a given line, wrapping around, which is the
+ * behaviour both a "next problem" button and a "previous problem" button need.
+ *
+ * A line of -1 starts at the beginning, and a line past the end starts again
+ * from the beginning, so a caller does not have to special-case either end.
+ * Returns undefined only when the log holds no issues.
+ */
+export declare const nextIssue: (issues: LogIssue[], line: number, direction?: IssueDirection) => LogIssue | undefined;

package/logs/sasLog.js

@@ -0,0 +1,254 @@
+"use strict";
+/**
+ * SAS log parsing.
+ *
+ * A SAS log is a stream of statements and messages, and only the messages
+ * matter to a reader looking for trouble: the ones SAS prints at the start of a
+ * line as `ERROR`, `WARNING` or `NOTE`. This module finds those messages and
+ * reports where they are, as line and column indexes into the text it was given,
+ * so a host can underline them without re-scanning the log and without rewriting
+ * it.
+ *
+ * What is recognised - the marker in capitals, beginning the line:
+ *
+ *   ERROR: Libref X is not assigned.
+ *   ERROR Libref Y is not assigned.
+ *   ERROR 22-322: Syntax error, expecting one of the following: ;, CANCEL,
+ *                 RUN, QUIT.
+ *   WARNING 1-322: Assuming the symbol Y was misspelled.
+ *   NOTE: Variable x is uninitialized.
+ *
+ * An error or a warning needs a colon, or a space, after the marker; `ERROR` on
+ * its own is not a message, and neither is every line that happens to begin with
+ * the word. The numeric code between the marker and the colon is SAS's own
+ * message identifier and is reported separately, so a host can group by it.
+ *
+ * NOTES are reported only when they are the ones the log-checking literature
+ * flags - see NOTE_KEYWORDS - and only in their colon form, because the notes
+ * stream is endless and the notable ones are a closed list. A coded note
+ * (`NOTE 49-169:`) is one of them and keeps its code. INFO lines are not
+ * reported at all.
+ *
+ * {@link isSasLog} answers the different question a host asks before publishing
+ * anything: whether this file is a SAS log at all. A Python log and a shell build
+ * log both write `ERROR:` at the start of a line, so the marker alone does not
+ * say so - the banner SAS prints about itself does, and so do its message codes
+ * and its padded step numbers.
+ *
+ * Lines SAS wrapped are folded into the message they belong to, so one problem
+ * is one issue rather than one issue per wrapped line, and the keyword search
+ * runs on the folded message - a note whose keyword lands on the second line is
+ * still found. Nothing indented counts as a marker, and neither does a marker in
+ * lower case: the real one starts the line, which keeps a print of a data set,
+ * or a message quoting another log, out of the results.
+ *
+ * ODS HTML logs wrap every line in markup. A tag sequence before the marker is
+ * skipped and tags are stripped from the reported message, so the same parse
+ * serves a plain log and an HTML one. The line and column indexes stay those of
+ * the text as supplied, because they are what the caller needs to address.
+ *
+ * Nothing here touches the log: the caller renders from the issue list, which is
+ * what lets one log be shown in an editor, in a browser panel and in a report
+ * from the same parse.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextIssue = exports.parseLog = exports.isNotableNote = exports.isSasLog = void 0;
+/**
+ * A marker at the start of a line: SAS writes `ERROR:` and `WARNING:` with a
+ * colon, and also writes them with no colon at all - `ERROR Libref X is not
+ * assigned.` - so a run of whitespace ends those two as well. The marker is
+ * uppercase and begins the line, which is what keeps a print of a data set, or a
+ * quotation of another log, out of the results.
+ *
+ * `NOTE` is a separate shape inside the same expression because it only counts
+ * with its colon: matching any line that begins NOTE would put the whole notes
+ * stream into the results. A coded note is a note - `NOTE 49-169:` carries the
+ * same kind of identifier an error does, and two of the notable keywords are
+ * written for coded notes.
+ *
+ * The tags of an ODS HTML log may lead the marker, with or without padding after
+ * them - they are markup the reader never sees, and the marker still begins the
+ * line's text. Padding without markup is not allowed: an indented marker is text
+ * in a listing, not a message. The prefix is captured so the marker's column is
+ * exact, and the code and message are captured separately.
+ */
+const MARKER = /^((?:<[^>]*>)+[ \t]*|)(?:(ERROR|WARNING)(?:\s+(\d+-\d+))?(:[ \t]?|[ \t]+)|(NOTE)(?:\s+(\d+-\d+))?:[ \t]?)(.*)$/;
+/** A line SAS numbers at the start, e.g. `1    data want;` - unlike a sequence number, it is padded. */
+const NUMBERED_STEP = /^\d+ {2,}\S/;
+/**
+ * The phrases SAS prints about itself, and nothing else does: the version banner,
+ * the licence note, the platform note, the work-area conversion warning, the page
+ * header of a listing and the step footer. Every SAS log carries at least one;
+ * a log that has lost its head usually keeps the step footer.
+ */
+const SAS_BANNER = /(?:The SAS System|^You are running SAS \d|^NOTE: (?:SAS|Copyright .*\bSAS Institute|This session is executing|DATA statement used))/m;
+/** A coded marker, e.g. `ERROR 22-322:` - SAS's message identifiers, again its own. */
+const CODED_MARKER = /^((?:<[^>]*>)+[ \t]*|)(?:ERROR|WARNING|NOTE) +\d+-\d+/;
+/**
+ * Whether a text is a SAS log rather than somebody else's log file.
+ *
+ * A marker alone does not say so: Python's logging writes `ERROR:root:boom` and
+ * a shell build log writes `ERROR: Command failed with exit code 1`, both at the
+ * start of a line. Nor does the word SAS - build logs of this estate's own
+ * repositories mention it in prose - so the test is SAS's own vocabulary: the
+ * banner it prints about itself, its message codes, and its padded step numbers.
+ * Each of those is written by SAS and by nothing else.
+ *
+ * This is a heuristic, and one way only: a true answer means SAS wrote the text,
+ * while a false answer does not prove it did not - a trimmed excerpt of a log,
+ * pasted with only its `ERROR:` lines, carries none of the three and reads as
+ * somebody else's. A host that publishes diagnostics should therefore treat false
+ * as "not obviously SAS" rather than "not SAS".
+ *
+ * Counting marker lines instead was considered and rejected: two `ERROR:` lines is
+ * what a Python log is made of, so it would readmit exactly the files this
+ * predicate exists to keep out.
+ *
+ * The check is deliberately cheap and runs before a host publishes anything, so
+ * a `.log` from another tool is left alone.
+ */
+const isSasLog = (text) => SAS_BANNER.test(text) ||
+    text
+        .split(/\r?\n/)
+        .some((line) => CODED_MARKER.test(line) || NUMBERED_STEP.test(line));
+exports.isSasLog = isSasLog;
+/**
+ * The notes worth reporting, matched case-insensitively against the folded
+ * message. Each is a message SAS prints when something has gone wrong quietly -
+ * a variable never set, a row that failed input, a value silently converted, a
+ * format too small to hold a number - and each is chased by the log checkers
+ * published in the SAS user-group papers: "Log Checks Made Easy" (SAS Global
+ * Forum 2012, 042-2012), "Check Please: An Automated Approach to Log Checking"
+ * (MWSUG 2017, TT02), "You've Got E-Mail: Automatic Log Checking via E-Mail
+ * Notification" (SUGI 31, 128-31) and the note table behind SASLogChecker.
+ *
+ * Adding a keyword widens what every host reports, so the list is deliberately
+ * short: a message belongs here when a reviewer would want to see it even though
+ * SAS called it a note.
+ */
+const NOTE_KEYWORDS = [
+    'is uninitialized',
+    'Missing values were generated',
+    'Division by zero',
+    'Mathematical operations could not be performed',
+    'Invalid data',
+    'Invalid argument',
+    'Invalid third argument',
+    'have been converted to',
+    'The meaning of an identifier',
+    'too small for',
+    'Unreferenced label',
+    'WHERE clause has been replaced',
+    'stopped due to looping',
+    'will be overwritten by data set',
+    'repeats of BY values',
+    'was not found',
+    'reached past the end of a line',
+    'LOST CARD',
+    'NOEXEC',
+    'A CASE expression has no ELSE clause',
+    'have been thinned',
+    'discarded because neither',
+    'Processing on disk occurred during summarization',
+    'log axis cannot support',
+    'lines were truncated',
+    'outside the axis range',
+    'infinite likelihood',
+    'not positive definite',
+    'The SAS System stopped processing this step because of errors'
+];
+const NOTABLE_NOTE_KEYWORDS = NOTE_KEYWORDS.map((keyword) => keyword.toLowerCase());
+/** How many wrapped lines one message may absorb, so a malformed log cannot run away. */
+const MAX_WRAPPED_LINES = 10;
+/** Whether a note's message is one of the notable ones. */
+const isNotableNote = (message) => {
+    const lower = message.toLowerCase();
+    return NOTABLE_NOTE_KEYWORDS.some((keyword) => lower.includes(keyword));
+};
+exports.isNotableNote = isNotableNote;
+/** A line SAS wrapped: indented, and not one of the pointer lines it prints under source. */
+const isWrappedLine = (line) => /^\s+\S/.test(line) &&
+    !/^\s*[-_]+\s*$/.test(line) &&
+    !/^\s*\d+\s*$/.test(line);
+/** Removes markup and collapses the whitespace a wrapped message carries. */
+const clean = (text) => text
+    .replace(/<[^>]*>/g, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+/**
+ * Finds every ERROR and WARNING in a SAS log, and every notable note.
+ *
+ * The issue list is in log order. `line` and `column` address the text as
+ * supplied, so a caller can offset a decoration or a diagnostic by them
+ * directly. A host that wants errors only filters on `severity`; nothing is
+ * behind an option, because a notable note is worth reporting wherever the log
+ * is shown.
+ */
+const parseLog = (text) => {
+    var _a, _b, _c;
+    if (!text) {
+        return [];
+    }
+    const lines = text.split(/\r?\n/);
+    const issues = [];
+    for (let line = 0; line < lines.length; line++) {
+        const match = MARKER.exec(lines[line]);
+        if (!match) {
+            continue;
+        }
+        const markerLine = line;
+        const parts = [clean((_a = match[7]) !== null && _a !== void 0 ? _a : '')];
+        let endLine = markerLine;
+        let wrapped = 0;
+        while (wrapped < MAX_WRAPPED_LINES &&
+            endLine + 1 < lines.length &&
+            isWrappedLine(lines[endLine + 1])) {
+            endLine++;
+            wrapped++;
+            parts.push(clean(lines[endLine]));
+        }
+        const severity = ((_b = match[2]) !== null && _b !== void 0 ? _b : match[5]).toLowerCase();
+        const message = parts.filter((part) => part !== '').join(' ');
+        // The wrapped lines belong to this message whether or not it is reported, so
+        // the scan resumes after them either way.
+        line = endLine;
+        // A marker with nothing after it is not a message: SAS does not print a bare
+        // `ERROR` or `ERROR:` line, and an empty issue would reach a host as a blank
+        // line in its problem list.
+        if (message === '') {
+            continue;
+        }
+        if (severity === 'note' && !(0, exports.isNotableNote)(message)) {
+            continue;
+        }
+        const code = (_c = match[3]) !== null && _c !== void 0 ? _c : match[6];
+        issues.push(Object.assign(Object.assign({ line: markerLine, endLine, column: match[1].length, endColumn: lines[markerLine].length, severity }, (code ? { code } : {})), { message }));
+    }
+    return issues;
+};
+exports.parseLog = parseLog;
+/**
+ * The issue after (or before) a given line, wrapping around, which is the
+ * behaviour both a "next problem" button and a "previous problem" button need.
+ *
+ * A line of -1 starts at the beginning, and a line past the end starts again
+ * from the beginning, so a caller does not have to special-case either end.
+ * Returns undefined only when the log holds no issues.
+ */
+const nextIssue = (issues, line, direction = 'next') => {
+    var _a;
+    if (issues.length === 0) {
+        return undefined;
+    }
+    if (direction === 'next') {
+        return (_a = issues.find((issue) => issue.line > line)) !== null && _a !== void 0 ? _a : issues[0];
+    }
+    for (let index = issues.length - 1; index >= 0; index--) {
+        if (issues[index].line < line) {
+            return issues[index];
+        }
+    }
+    return issues[issues.length - 1];
+};
+exports.nextIssue = nextIssue;
+//# sourceMappingURL=sasLog.js.map

package/logs/sasLog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sasLog.js","sourceRoot":"","sources":["../../src/logs/sasLog.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -46,6 +46,7 @@
     "fs/**",
     "input/**",
     "logger/**",
+    "logs/**",
     "macros/**",
     "sasjsCli/**",
     "time/**",
@@ -95,5 +96,5 @@
     "jwt-decode": "4.0.0",
     "prompts": "2.4.2"
   },
-  "version": "4.1.2"
+  "version": "4.3.0"
 }