fhirsmith 0.18.1 → 1.0.0

package/library/daily-report.js

@@ -12,6 +12,9 @@
 // The report is:
 //  - a paragraph on the server's own stability since the last report: how much of the
 //    time it was up, restarts, and any upgrade (from the run history ServerStats keeps)
+//  - under the launcher (cluster.js), a paragraph on the cluster: processes that exited or
+//    were recycled and how long they were unavailable, and what the launcher refused or
+//    abandoned itself (library/cluster-events.js)
 //  - a paragraph from each running module that has something to say. A module takes part
 //    by having `dailyReport({since, now})` return markdown (a string, or a promise of one);
 //    an empty return means no paragraph. By default modules have nothing to say
@@ -94,6 +97,11 @@ function describeSpan(ms) {
   return plural(Math.round(hours / 24), 'day');
 }
 
+/** "once", "twice", "3 times" */
+function times(n) {
+  return n === 1 ? 'once' : n === 2 ? 'twice' : `${n} times`;
+}
+
 function plural(n, word) {
   return `${n} ${word}${n === 1 ? '' : 's'}`;
 }
@@ -112,9 +120,10 @@ class DailyReport {
 
   /**
    * @param config - the "dailyReport" block
-   * @param deps - {log, stats, modules, mailer, npmAudit, version, serverId, stateFile}
+   * @param deps - {log, stats, modules, mailer, npmAudit, version, serverId, stateFile, cluster}
    *   modules is the server's {name: instance} map; npmAudit the server's NpmAudit (optional);
-   *   version the server's version; serverId the name the report goes out under (config.hostName)
+   *   version the server's version; serverId the name the report goes out under (config.hostName);
+   *   cluster true for the master under the launcher (the cluster paragraph is always there)
    */
   constructor(config, deps) {
     this.config = config || {};
@@ -125,6 +134,7 @@ class DailyReport {
     this.npmAudit = deps.npmAudit || null;
     this.version = deps.version;
     this.serverId = deps.serverId || os.hostname();
+    this.cluster = Boolean(deps.cluster);
     this.stateFile = deps.stateFile || folders.filePath(STATE_FILE);
     this.timer = null;
     this.running = false;
@@ -255,6 +265,11 @@ class DailyReport {
     parts.push(`# ${this.serverId} daily report for ${localDateTime(now)} covering the last ${describeSpan(now - since)}`);
     parts.push('## Stability');
     parts.push(this.stabilityParagraph(since, now));
+    const cluster = this.clusterParagraph(since, now);
+    if (cluster) {
+      parts.push('## Cluster');
+      parts.push(cluster);
+    }
     for (const [name, module] of Object.entries(this.modules)) {
       const text = await this.moduleParagraph(name, module, since, now);
       if (text) {
@@ -333,6 +348,88 @@ class DailyReport {
     return sentences.join(' ');
   }
 
+  /**
+   * Under the launcher: what it saw (library/cluster-events.js) - processes that exited or
+   * were recycled, how long each was unavailable, and what it answered itself. Null for a
+   * single server (no role, and no events recorded).
+   */
+  clusterParagraph(since, now) {
+    const events = this.stats && typeof this.stats.clusterEventsSince === 'function' ? this.stats.clusterEventsSince(since, now) : null;
+    if (!this.cluster && !(events && events.length > 0)) {
+      return null;
+    }
+    if (!events) {
+      return 'No record of the launcher\'s events is available (the statistics database is not in use).';
+    }
+    const sum = (rows) => rows.reduce((n, r) => n + r.count, 0);
+    const of = (kind, process) => events.filter(e => e.kind === kind && (process === undefined || e.process === process));
+    const sentences = [];
+    const started = of('launcher-started');
+    if (started.length > 0) {
+      sentences.push(`The launcher started ${times(started.length)} (${started.map(e => localDateTime(e.time)).join(', ')}).`);
+    }
+
+    const names = [...new Set(events.filter(e => e.process).map(e => e.process))]
+      .sort((a, b) => (a === 'master' ? -1 : b === 'master' ? 1 : a.localeCompare(b)));
+    const lines = [];
+    for (const name of names) {
+      const said = [];
+      const exited = of('exited', name);
+      if (exited.length > 0) {
+        const how = new Map();
+        for (const e of exited) {
+          const d = e.detail == null ? 'unknown' : /^-?\d+$/.test(e.detail) ? `exit code ${e.detail}` : e.detail;
+          how.set(d, (how.get(d) || 0) + 1);
+        }
+        said.push(`exited ${times(exited.length)} (${[...how].map(([d, n]) => n > 1 ? `${n} × ${d}` : d).join(', ')})`);
+      }
+      const recycled = of('recycled', name);
+      if (recycled.length > 0) {
+        said.push(`was recycled ${times(recycled.length)} (the last because ${recycled[recycled.length - 1].detail || 'of its memory'})`);
+      }
+      const down = of('ready', name).reduce((n, e) => n + e.ms, 0);
+      if (down > 0) {
+        said.push(`was unavailable for ${formatSpan(down)} in all`);
+      }
+      const timedOut = sum(of('upstream-timeout', name));
+      if (timedOut > 0) {
+        said.push(`did not begin ${plural(timedOut, 'response')} in time (504)`);
+      }
+      const failed = sum(of('upstream-failed', name));
+      if (failed > 0) {
+        said.push(`failed to answer ${plural(failed, 'request')} (502)`);
+      }
+      const lost = sum(of('lost-to-restart', name));
+      if (lost > 0) {
+        said.push(`was restarting when ${plural(lost, 'request')} came for a cache-id it had issued`);
+      }
+      if (said.length > 0) {
+        lines.push(`- ${name}: ${said.join('; ')}`);
+      }
+    }
+    if (of('exited').length === 0 && of('recycled').length === 0) {
+      sentences.push('No process exited or was recycled.');
+    }
+
+    const refused = [
+      [sum(of('refused-busy')), 'because no process was free in time'],
+      [sum(of('refused-not-ready')), 'because no process was ready'],
+      [sum(of('refused-stopping')), 'while it was stopping']
+    ].filter(([n]) => n > 0);
+    if (refused.length > 0) {
+      const total = refused.reduce((n, [c]) => n + c, 0);
+      sentences.push(`The launcher refused ${plural(total, 'request')} itself (503): ${refused.map(([n, why]) => `${n} ${why}`).join(', ')}.`);
+    } else {
+      sentences.push('The launcher refused no requests itself.');
+    }
+    const cut = sum(of('write-timeout'));
+    if (cut > 0) {
+      sentences.push(`It closed ${plural(cut, 'connection')} whose client took none of a response in time (writeTimeoutSeconds).`);
+    }
+    const text = sentences.join(' ');
+    return lines.length > 0 ? `${text}\n\n${lines.join('\n')}` : text;
+  }
+
   /**
    * A module's paragraph, if it has one. A module that throws gets a line
    * saying so rather than taking the report down.
@@ -430,3 +527,4 @@ module.exports.describeSpan = describeSpan;
 // for modules writing their paragraph: "3 packages", "1 package"
 module.exports.plural = plural;
 module.exports.localDateTime = localDateTime;
+module.exports.formatBytes = formatBytes;

package/library/html-server.js

@@ -12,11 +12,24 @@ const packageJson = require('../package.json');
 
 let sponsorMessage = '';
 
+// The accessibility check panel (config accessibility.checkPanel): a button at the bottom of
+// every page that runs axe-core (WCAG 2.0 A/AA) and FHIRsmith's own structure checks on the page
+// as the browser has it. The scripts are in static/a11y/; a11y-check.js only loads axe-core when
+// the button is pressed.
+const A11Y_PANEL = `
+<div id="fhir-a11y-panel" data-axe="/a11y/axe.min.js" lang="en" style="clear: both; margin: 20px 10px; padding: 8px; border: 1px solid #888888; background-color: #f4f4f4; color: #000000; font-size: 13px; font-family: sans-serif">
+<p style="margin: 0"><b>Accessibility check</b> (checks this page as it is now against WCAG 2.0 A/AA, plus heading structure, reported by HHS 508 checklist item) <button type="button" class="fhir-a11y-run">Check this page</button> <span class="fhir-a11y-status" role="status"></span></p>
+<div class="fhir-a11y-results"></div>
+</div>
+<script type="text/javascript" src="/a11y/a11y-check.js"></script>
+`;
+
 class HtmlServer {
   log;
 
   constructor() {
     this.templates = new Map(); // templateName -> template content
+    this.accessibilityPanel = false;
   }
 
   useLog(logv) {
@@ -27,6 +40,17 @@ class HtmlServer {
     sponsorMessage = msg;
   }
 
+  setAccessibilityPanel(enabled) {
+    this.accessibilityPanel = !!enabled;
+  }
+
+  // put the accessibility check panel at the end of the page body (or the end of the page, if
+  // there's no </body>)
+  addAccessibilityPanel(html) {
+    const i = html.toLowerCase().lastIndexOf('</body>');
+    return i < 0 ? html + A11Y_PANEL : html.slice(0, i) + A11Y_PANEL + html.slice(i);
+  }
+
   // Template Management
   loadTemplate(templateName, templatePath) {
     try {
@@ -92,6 +116,8 @@ class HtmlServer {
       ['library-link', () => renderOptions.libraryLink || ''],
       // raw HTML too: the OpenAPI description, where a template's module has one in some places only
       ['api-link', () => renderOptions.apiLink || ''],
+      // raw HTML: the packages module's feed check, in the nav bar only when it's enabled
+      ['feed-check-link', () => renderOptions.feedCheckLink || ''],
       // raw HTML: a link to the current project (or other context) in the nav bar, where the
       // module has one
       ['context-link', () => renderOptions.contextLink || ''],
@@ -108,7 +134,7 @@ class HtmlServer {
     // a placeholder that isn't known is left as it is, as before
     const html = template.replace(/\[%([^%\]\s]{1,64})%\]/g, (m, name) => (values.has(name) ? values.get(name)() : m));
 
-    return html;
+    return this.accessibilityPanel ? this.addAccessibilityPanel(html) : html;
   }
 
   // Express Response Helper

package/library/i18nsupport.js

@@ -254,6 +254,28 @@ class I18nSupport {
   }
 }
 
+let english = null;
+
+/**
+ * A message from translations/Messages.properties, in English, with its parameters, as
+ * I18nSupport.translate gives it: for code with no request languages to hand (the shared
+ * cache store's lazy reads, the launcher). The message id goes with it, so a client (or a
+ * caller that has the languages: msgParams) can render it in another language.
+ * @param {string} messageId
+ * @param {Array} [parameters]
+ */
+function englishMessage(messageId, parameters = []) {
+  if (!english) {
+    english = getProperties(fs.readFileSync(path.join(__dirname, '..', 'translations', 'Messages.properties'), 'utf8'));
+  }
+  const message = english[messageId];
+  if (!message) {
+    return messageId;
+  }
+  return I18nSupport.prototype._substituteParameters(message.trim(), parameters).replaceAll("''", "'");
+}
+
 module.exports = {
-  I18nSupport
+  I18nSupport,
+  englishMessage
 };

package/library/keep-alive.js

@@ -0,0 +1,18 @@
+// Keep-alive timeouts for the HTTP server behind a reverse proxy.
+//
+// nginx keeps idle upstream connections open for 60 s (keepalive_timeout in an upstream block),
+// while Node closes an idle one after 5 s. When nginx reuses a connection at the moment Node
+// closes it, the request fails with a reset, and nginx does not retry a POST: the client gets a
+// 502. Node must therefore keep idle connections open longer than the proxy does, and
+// headersTimeout must be longer still, or Node applies it to the idle connection first.
+
+const KEEP_ALIVE_TIMEOUT_MS = 65000;
+const HEADERS_TIMEOUT_MS = 66000;
+
+function applyKeepAliveTimeouts(server) {
+  server.keepAliveTimeout = KEEP_ALIVE_TIMEOUT_MS;
+  server.headersTimeout = HEADERS_TIMEOUT_MS;
+  return server;
+}
+
+module.exports = { applyKeepAliveTimeouts, KEEP_ALIVE_TIMEOUT_MS, HEADERS_TIMEOUT_MS };

package/library/languages.js

@@ -583,6 +583,12 @@ class Languages {
  * Global language definitions loaded from IETF registry
  */
 class LanguageDefinitions {
+  // Private use tags of any length are valid, so the cache of parsed tags is capped
+  // with a simple LRU (as RegExUtilities does), or unique tags would grow it forever.
+  // Default for languageTagCacheSize: an 8 KB tag takes about 46 KB parsed, so 1,000
+  // such tags are at most about 46 MB; real requests use far fewer distinct tags.
+  static MAX_PARSED = 1000;
+
   constructor() {
     this.languages = new Map();
     this.extLanguages = new Map();
@@ -596,6 +602,7 @@ class LanguageDefinitions {
     // case-insensitive, and the registry writes these in mixed case.
     this.wholeTags = new Map();
     this.parsed = new Map(); // Cache for parsed languages
+    this.maxParsed = LanguageDefinitions.MAX_PARSED; // Infinity = no limit
   }
 
   /**
@@ -949,13 +956,20 @@ class LanguageDefinitions {
     // The cache key carries the options: the same tag can be valid under one set of
     // rules and not another, so a lenient parse must not be served to a strict caller.
     const key = (options.caseInsensitive ? 'i' : '') + (options.checkCombinations ? 'c' : '') + ':' + code;
-    if (this.parsed.has(key)) {
-      return this.parsed.get(key);
+    const cached = this.parsed.get(key);
+    if (cached) {
+      // Move to most-recently-used position by re-inserting.
+      this.parsed.delete(key);
+      this.parsed.set(key, cached);
+      return cached;
     }
 
     try {
       const lang = new Language(code, this, options);
-      // Cache the result
+      if (this.parsed.size >= this.maxParsed) {
+        // Evict the oldest entry: Map iteration order is insertion order.
+        this.parsed.delete(this.parsed.keys().next().value);
+      }
       this.parsed.set(key, lang);
       return lang;
     } catch (e) {

package/library/logger.js

@@ -299,6 +299,37 @@ class Logger {
     };
   }
 
+  // Apply config.logging to a logger that is already running (the server starts logging with the
+  // defaults before config.json is read). Same options as the constructor; anything not given keeps
+  // its default
+  configure(options = {}) {
+    this._flushSync();
+    this.level = options.level || DEFAULTS.level;
+    this.maxFiles = options.maxFiles ?? DEFAULTS.maxFiles;
+    this.maxSize = Logger._parseSize(options.maxSize) || DEFAULTS.maxSize;
+    this.showConsole = options.console ?? DEFAULTS.console;
+    this.consoleErrors = options.consoleErrors ?? DEFAULTS.consoleErrors;
+    this._flushSize = options.flushSize ?? DEFAULTS.flushSize;
+
+    clearInterval(this._flushTimer);
+    this._flushTimer = setInterval(() => this._flush(), options.flushInterval ?? DEFAULTS.flushInterval);
+    if (this._flushTimer.unref) this._flushTimer.unref();
+
+    if (options.logDir && path.resolve(options.logDir) !== path.resolve(this.logDir)) {
+      if (this._fd !== null) {
+        try { fs.closeSync(this._fd); } catch (_) { /* intentional */ }
+      }
+      this._fd = null;
+      this._currentDate = null;
+      this._currentFileSize = 0;
+      this.logDir = options.logDir;
+      if (!fs.existsSync(this.logDir)) {
+        fs.mkdirSync(this.logDir, { recursive: true });
+      }
+    }
+    this.info('Logger configured @ ' + this.logDir + ', level ' + this.level, {});
+  }
+
   setLevel(level) {
     this.level = level;
     this.info(`Log level changed to ${level}`);