@agoric/telemetry 0.6.3-other-dev-1f26562.0 → 0.6.3-other-dev-3eb1a1d.0

package/src/otel-context-aware-slog.js

@@ -0,0 +1,131 @@
+/* eslint-env node */
+import { logs, SeverityNumber } from '@opentelemetry/api-logs';
+import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
+import { Resource } from '@opentelemetry/resources';
+import {
+  LoggerProvider,
+  SimpleLogRecordProcessor,
+} from '@opentelemetry/sdk-logs';
+import { readFileSync, writeFileSync } from 'fs';
+import { makeContextualSlogProcessor } from './context-aware-slog.js';
+import { getResourceAttributes } from './index.js';
+import { serializeSlogObj } from './serialize-slog-obj.js';
+
+const DEFAULT_CONTEXT_FILE = 'slog-context.json';
+const FILE_ENCODING = 'utf8';
+
+/**
+ * @param {string} filePath
+ */
+export const getContextFilePersistenceUtils = filePath => {
+  console.warn(`Using file ${filePath} for slogger context`);
+
+  return {
+    /**
+     * @param {import('./context-aware-slog.js').Context} context
+     */
+    persistContext: context => {
+      try {
+        writeFileSync(filePath, serializeSlogObj(context), FILE_ENCODING);
+      } catch (err) {
+        console.error('Error writing context to file: ', err);
+      }
+    },
+
+    /**
+     * @returns {import('./context-aware-slog.js').Context | null}
+     */
+    restoreContext: () => {
+      try {
+        return JSON.parse(readFileSync(filePath, FILE_ENCODING));
+      } catch (parseErr) {
+        console.error('Error reading context from file: ', parseErr);
+        return null;
+      }
+    },
+  };
+};
+
+/**
+ * @param {import('./index.js').MakeSlogSenderOptions} options
+ */
+export const makeSlogSender = async options => {
+  const { CHAIN_ID, OTEL_EXPORTER_OTLP_ENDPOINT } = options.env || {};
+  if (!(OTEL_EXPORTER_OTLP_ENDPOINT && options.stateDir))
+    return console.error(
+      'Ignoring invocation of slogger "context-aware-slog" without the presence of "OTEL_EXPORTER_OTLP_ENDPOINT" and "stateDir"',
+    );
+
+  const loggerProvider = new LoggerProvider({
+    resource: new Resource(getResourceAttributes(options)),
+  });
+
+  const otelLogExporter = new OTLPLogExporter({ keepAlive: true });
+  const logRecordProcessor = new SimpleLogRecordProcessor(otelLogExporter);
+
+  loggerProvider.addLogRecordProcessor(logRecordProcessor);
+
+  logs.setGlobalLoggerProvider(loggerProvider);
+  const logger = logs.getLogger('default');
+
+  const persistenceUtils = getContextFilePersistenceUtils(
+    process.env.SLOG_CONTEXT_FILE_PATH ||
+      `${options.stateDir}/${DEFAULT_CONTEXT_FILE}`,
+  );
+
+  const contextualSlogProcessor = makeContextualSlogProcessor(
+    { 'chain-id': CHAIN_ID },
+    persistenceUtils,
+  );
+
+  /**
+   * @param {import('./context-aware-slog.js').Slog} slog
+   */
+  const slogSender = slog => {
+    const { timestamp, ...logRecord } = contextualSlogProcessor(slog);
+
+    const [secondsStr, fractionStr] = String(timestamp).split('.');
+    const seconds = parseInt(secondsStr, 10);
+    const nanoSeconds = parseInt(
+      (fractionStr || String(0)).padEnd(9, String(0)).slice(0, 9),
+      10,
+    );
+
+    logger.emit({
+      ...JSON.parse(serializeSlogObj(logRecord)),
+      severityNumber: SeverityNumber.INFO,
+      timestamp: [seconds, nanoSeconds],
+    });
+  };
+
+  const shutdown = async () => {
+    await Promise.resolve();
+    const errors = [];
+
+    try {
+      await logRecordProcessor.shutdown();
+    } catch (err) {
+      errors.push(err);
+    }
+
+    try {
+      await otelLogExporter.forceFlush();
+    } catch (err) {
+      errors.push(err);
+    }
+
+    switch (errors.length) {
+      case 0:
+        return;
+      case 1:
+        throw errors[0];
+      default:
+        throw AggregateError(errors);
+    }
+  };
+
+  return Object.assign(slogSender, {
+    forceFlush: () => otelLogExporter.forceFlush(),
+    shutdown,
+  });
+};

package/src/slog-file.js

@@ -11,7 +11,7 @@ export const makeSlogSender = async ({ env: { SLOGFILE } = {} } = {}) => {
 
   const slogSender = (slogObj, jsonObj = serializeSlogObj(slogObj)) => {
     // eslint-disable-next-line prefer-template
-    void stream.write(jsonObj + '\n');
+    stream.write(jsonObj + '\n').catch(() => {});
   };
 
   return Object.assign(slogSender, {

package/src/slog-sender-pipe-entrypoint.js

@@ -1,7 +1,6 @@
-/* global process */
+/* eslint-env node */
 import '@endo/init';
 
-import { makeAggregateError } from '@agoric/internal';
 import anylogger from 'anylogger';
 import { makeShutdown } from '@agoric/internal/src/node/shutdown.js';
 
@@ -75,7 +74,7 @@ const main = async () => {
       sendErrors.unshift(actualFlushError);
     }
 
-    return makeAggregateError(sendErrors.splice(0));
+    return AggregateError(sendErrors.splice(0));
   };
 
   process.on(
@@ -130,7 +129,13 @@ const main = async () => {
   );
 };
 
-main().catch(e => {
-  logger.error(e);
-  process.exitCode = 1;
-});
+process.exitCode = 1;
+main().then(
+  () => {
+    process.exitCode = 0;
+  },
+  err => {
+    logger.error('Failed with', err);
+    process.exit(process.exitCode || 1);
+  },
+);

package/src/slog-sender-pipe.js

@@ -6,8 +6,7 @@ import { makeQueue } from '@endo/stream';
 
 import { makeShutdown } from '@agoric/internal/src/node/shutdown.js';
 
-const filename = new URL(import.meta.url).pathname;
-const dirname = path.dirname(filename);
+const dirname = path.dirname(new URL(import.meta.url).pathname);
 
 const logger = anylogger('slog-sender-pipe');
 
@@ -78,11 +77,11 @@ export const makeSlogSender = async opts => {
   /**
    * @typedef {{
    *   init: {
-   *     message: import('./slog-sender-pipe-entrypoint').InitMessage;
+   *     message: import('./slog-sender-pipe-entrypoint.js').InitMessage;
    *     reply: SlogSenderInitReply;
    *   };
    *   flush: {
-   *     message: import('./slog-sender-pipe-entrypoint').FlushMessage;
+   *     message: import('./slog-sender-pipe-entrypoint.js').FlushMessage;
    *     reply: SlogSenderFlushReply;
    *   };
    * }} SlogSenderWaitMessagesAndReplies

package/src/slog-to-otel.js

@@ -1,7 +1,7 @@
 import otel, { SpanStatusCode } from '@opentelemetry/api';
 
+import { Fail, q } from '@endo/errors';
 import { makeMarshal, Remotable } from '@endo/marshal';
-import { Fail, q } from '@agoric/assert';
 
 import { makeLegacyMap } from '@agoric/store';
 import {
@@ -14,11 +14,8 @@ import {
 
 // diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.VERBOSE);
 
-/** @typedef {import('@opentelemetry/api').Span} Span */
-/** @typedef {import('@opentelemetry/api').Link} SpanLink */
-/** @typedef {import('@opentelemetry/api').SpanContext} SpanContext */
-/** @typedef {import('@opentelemetry/api').SpanOptions} SpanOptions */
-/** @typedef {import('@opentelemetry/api').SpanAttributes} SpanAttributes */
+/** @import {Span, Link as SpanLink} from '@opentelemetry/api' */
+/** @import {SpanContext, SpanOptions} from '@opentelemetry/api' */
 
 const { assign } = Object;
 
@@ -54,9 +51,9 @@ const serializeInto = (value, prefix, target = {}, depth = 3) => {
       } else {
         const proto = Object.getPrototypeOf(value);
         if (proto == null || proto === Object.prototype) {
-          Object.entries(value).forEach(([key, nested]) =>
-            serializeInto(nested, `${prefix}.${key}`, target, depth),
-          );
+          for (const [key, nested] of Object.entries(value)) {
+            serializeInto(nested, `${prefix}.${key}`, target, depth);
+          }
           return target;
         }
       }
@@ -142,7 +139,10 @@ export const makeSlogToOtelKit = (tracer, overrideAttrs = {}) => {
     serializeBodyFormat: 'smallcaps',
   });
 
-  /** @param {import('@agoric/swingset-vat').SwingSetCapData} data */
+  /**
+   * @param {import('@agoric/swingset-vat').SwingSetCapData} data
+   * @returns {any}
+   */
   const unserialize = data => {
     try {
       const body = rawUnserialize(data);
@@ -915,7 +915,7 @@ export const makeSlogToOtelKit = (tracer, overrideAttrs = {}) => {
         break;
       }
       case 'cosmic-swingset-upgrade-finish': {
-        spans.pop(['slogAttrs.blockHeight', slogAttrs.blockHeight]);
+        spans.pop(['upgrade', slogAttrs.blockHeight]);
         dbTransactionManager.end();
         break;
       }
@@ -971,6 +971,21 @@ export const makeSlogToOtelKit = (tracer, overrideAttrs = {}) => {
         spans.pop('bridge-inbound');
         break;
       }
+      case 'cosmic-swingset-timer-poll': {
+        spans.push(['timer-poll', slogAttrs.blockTime]);
+        spans.pop('timer-poll');
+        break;
+      }
+      case 'cosmic-swingset-inject-kernel-upgrade-events': {
+        spans.push('kernel-upgrade-events');
+        spans.pop('kernel-upgrade-events');
+        break;
+      }
+      case 'cosmic-swingset-install-bundle': {
+        spans.push(['install-bundle', slogAttrs.endoZipBase64Sha512]);
+        spans.pop('install-bundle');
+        break;
+      }
       case 'cosmic-swingset-end-block-start': {
         // Add `end-block` as an event onto the encompassing `block` span
         spans.top()?.addEvent('end-block-action', cleanAttrs(slogAttrs), now);

package/test/flight-recorder.test.js

@@ -0,0 +1,83 @@
+import fs from 'node:fs';
+import tmp from 'tmp';
+import { test } from './prepare-test-env-ava.js';
+
+import {
+  makeSimpleCircularBuffer,
+  makeSlogSenderFromBuffer,
+} from '../src/flight-recorder.js';
+
+// Factored this way to support multiple implementations, which at one point there were
+const bufferTests = test.macro(
+  /**
+   *
+   * @param {*} t
+   * @param {{makeBuffer: Function}} input
+   */
+  async (t, input) => {
+    const BUFFER_SIZE = 512;
+
+    const { name: tmpFile, removeCallback } = tmp.fileSync();
+    const { readCircBuf, writeCircBuf } = await input.makeBuffer({
+      circularBufferSize: BUFFER_SIZE,
+      circularBufferFilename: tmpFile,
+    });
+    const slogSender = makeSlogSenderFromBuffer({ writeCircBuf });
+    slogSender({ type: 'start' });
+    await slogSender.forceFlush();
+    t.is(fs.readFileSync(tmpFile, { encoding: 'utf8' }).length, BUFFER_SIZE);
+
+    const len0 = new Uint8Array(BigUint64Array.BYTES_PER_ELEMENT);
+    const { done: done0 } = readCircBuf(len0);
+    t.false(done0, 'readCircBuf should not be done');
+    const dv0 = new DataView(len0.buffer);
+    const buf0 = new Uint8Array(Number(dv0.getBigUint64(0)));
+    const { done: done0b } = readCircBuf(buf0, len0.byteLength);
+    t.false(done0b, 'readCircBuf should not be done');
+    const buf0Str = new TextDecoder().decode(buf0);
+    t.is(buf0Str, `\n{"type":"start"}`, `start compare failed`);
+
+    const last = 500;
+    for (let i = 0; i < last; i += 1) {
+      slogSender({ type: 'iteration', iteration: i });
+      await slogSender.forceFlush();
+      t.is(
+        fs.readFileSync(tmpFile, { encoding: 'utf8' }).length,
+        BUFFER_SIZE,
+        `iteration ${i} length mismatch`,
+      );
+    }
+
+    let offset = 0;
+    const len1 = new Uint8Array(BigUint64Array.BYTES_PER_ELEMENT);
+    for (let i = 490; i < last; i += 1) {
+      const { done: done1 } = readCircBuf(len1, offset);
+      offset += len1.byteLength;
+      t.false(done1, `readCircBuf ${i} should not be done`);
+      const dv1 = new DataView(len1.buffer);
+      const buf1 = new Uint8Array(Number(dv1.getBigUint64(0)));
+      const { done: done1b } = readCircBuf(buf1, offset);
+      offset += buf1.byteLength;
+      t.false(done1b, `readCircBuf ${i} should not be done`);
+      const buf1Str = new TextDecoder().decode(buf1);
+      t.is(
+        buf1Str,
+        `\n{"type":"iteration","iteration":${i}}`,
+        `iteration ${i} compare failed`,
+      );
+    }
+
+    const { done: done2 } = readCircBuf(len1, offset);
+    t.assert(done2, `readCircBuf ${last} should be done`);
+
+    slogSender(null, 'PRE-SERIALIZED');
+    await slogSender.forceFlush();
+    t.truthy(fs.readFileSync(tmpFile).includes('PRE-SERIALIZED'));
+    // console.log({ tmpFile });
+    removeCallback();
+  },
+);
+
+test('simple', bufferTests, {
+  makeBuffer: makeSimpleCircularBuffer,
+});

package/test/prepare-test-env-ava.js

@@ -1,5 +1,3 @@
-import '@endo/init';
-
 import { wrapTest } from '@endo/ses-ava';
 import rawTest from 'ava';
 

package/{jsconfig.json → tsconfig.json}

@@ -1,6 +1,7 @@
 // This file can contain .js-specific Typescript compiler config.
 {
   "extends": "../../tsconfig.json",
+  "compilerOptions": {},
   "include": [
     "*.js",
     "scripts",

package/test/test-flight-recorder.js

@@ -1,53 +0,0 @@
-import tmp from 'tmp';
-import { test } from './prepare-test-env-ava.js';
-
-import { makeMemoryMappedCircularBuffer } from '../src/flight-recorder.js';
-
-test('flight-recorder sanity', async t => {
-  const { name: tmpFile, removeCallback } = tmp.fileSync();
-  const { writeJSON: slogSender, readCircBuf } =
-    await makeMemoryMappedCircularBuffer({
-      circularBufferSize: 512,
-      circularBufferFilename: tmpFile,
-    });
-  slogSender({ type: 'start' });
-
-  const len0 = new Uint8Array(BigUint64Array.BYTES_PER_ELEMENT);
-  const { done: done0 } = readCircBuf(len0);
-  t.false(done0, 'readCircBuf should not be done');
-  const dv0 = new DataView(len0.buffer);
-  const buf0 = new Uint8Array(Number(dv0.getBigUint64(0)));
-  const { done: done0b } = readCircBuf(buf0, len0.byteLength);
-  t.false(done0b, 'readCircBuf should not be done');
-  const buf0Str = new TextDecoder().decode(buf0);
-  t.is(buf0Str, `\n{"type":"start"}`, `start compare failed`);
-
-  const last = 500;
-  for (let i = 0; i < last; i += 1) {
-    slogSender({ type: 'iteration', iteration: i });
-  }
-
-  let offset = 0;
-  const len1 = new Uint8Array(BigUint64Array.BYTES_PER_ELEMENT);
-  for (let i = 490; i < last; i += 1) {
-    const { done: done1 } = readCircBuf(len1, offset);
-    offset += len1.byteLength;
-    t.false(done1, `readCircBuf ${i} should not be done`);
-    const dv1 = new DataView(len1.buffer);
-    const buf1 = new Uint8Array(Number(dv1.getBigUint64(0)));
-    const { done: done1b } = readCircBuf(buf1, offset);
-    offset += buf1.byteLength;
-    t.false(done1b, `readCircBuf ${i} should not be done`);
-    const buf1Str = new TextDecoder().decode(buf1);
-    t.is(
-      buf1Str,
-      `\n{"type":"iteration","iteration":${i}}`,
-      `iteration ${i} compare failed`,
-    );
-  }
-
-  const { done: done2 } = readCircBuf(len1, offset);
-  t.assert(done2, `readCircBuf ${last} should be done`);
-  // console.log({ tmpFile });
-  removeCallback();
-});