@tracewayapp/opamp 0.0.0-stage → 2.0.0-beta.1

package/dist/index.js

@@ -0,0 +1,618 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AgentCapabilities: () => AgentCapabilities,
+  AgentToServerFlags: () => AgentToServerFlags,
+  OpampHttpClient: () => OpampHttpClient,
+  RemoteConfigStatus: () => RemoteConfigStatus,
+  ServerErrorType: () => ServerErrorType,
+  ServerToAgentFlags: () => ServerToAgentFlags,
+  decodeServerToAgent: () => decodeServerToAgent,
+  encodeAgentToServer: () => encodeAgentToServer,
+  encodeServerToAgent: () => encodeServerToAgent,
+  uuidString: () => uuidString
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/wire.ts
+var WIRE_VARINT = 0;
+var WIRE_FIXED64 = 1;
+var WIRE_LENGTH = 2;
+var WIRE_FIXED32 = 5;
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+var Writer = class _Writer {
+  chunks = [];
+  varint(value) {
+    let v = Math.max(0, Math.floor(value));
+    while (v >= 128) {
+      this.chunks.push(v % 128 | 128);
+      v = Math.floor(v / 128);
+    }
+    this.chunks.push(v);
+    return this;
+  }
+  tag(field, wireType) {
+    return this.varint(field * 8 + wireType);
+  }
+  uint(field, value) {
+    if (value === 0) return this;
+    return this.tag(field, WIRE_VARINT).varint(value);
+  }
+  bool(field, value) {
+    return value ? this.tag(field, WIRE_VARINT).varint(1) : this;
+  }
+  bytes(field, value) {
+    if (value.length === 0) return this;
+    this.tag(field, WIRE_LENGTH).varint(value.length);
+    for (const b of value) this.chunks.push(b);
+    return this;
+  }
+  string(field, value) {
+    return this.bytes(field, encoder.encode(value));
+  }
+  double(field, value) {
+    if (value === 0) return this;
+    const buf = new DataView(new ArrayBuffer(8));
+    buf.setFloat64(0, value, true);
+    this.tag(field, WIRE_FIXED64);
+    for (let i = 0; i < 8; i++) this.chunks.push(buf.getUint8(i));
+    return this;
+  }
+  /** Writes a nested message. An empty message is still written when `always` is set (presence matters). */
+  message(field, build, always = false) {
+    const inner = new _Writer();
+    build(inner);
+    const bytes = inner.finish();
+    if (bytes.length === 0 && !always) return this;
+    this.tag(field, WIRE_LENGTH).varint(bytes.length);
+    for (const b of bytes) this.chunks.push(b);
+    return this;
+  }
+  finish() {
+    return Uint8Array.from(this.chunks);
+  }
+};
+var Reader = class {
+  constructor(buf) {
+    this.buf = buf;
+  }
+  buf;
+  pos = 0;
+  done() {
+    return this.pos >= this.buf.length;
+  }
+  varint() {
+    let result = 0;
+    let multiplier = 1;
+    for (; ; ) {
+      if (this.pos >= this.buf.length) throw new Error("truncated varint");
+      const byte = this.buf[this.pos++];
+      result += (byte & 127) * multiplier;
+      if (byte < 128) return result;
+      multiplier *= 128;
+      if (multiplier > 2 ** 70) throw new Error("varint too long");
+    }
+  }
+  tag() {
+    const tag = this.varint();
+    return { field: Math.floor(tag / 8), wireType: tag % 8 };
+  }
+  bytes() {
+    const length = this.varint();
+    if (this.pos + length > this.buf.length) throw new Error("truncated field");
+    const out = this.buf.subarray(this.pos, this.pos + length);
+    this.pos += length;
+    return out;
+  }
+  string() {
+    return decoder.decode(this.bytes());
+  }
+  double() {
+    if (this.pos + 8 > this.buf.length) throw new Error("truncated double");
+    const view = new DataView(this.buf.buffer, this.buf.byteOffset + this.pos, 8);
+    this.pos += 8;
+    return view.getFloat64(0, true);
+  }
+  skip(wireType) {
+    switch (wireType) {
+      case WIRE_VARINT:
+        this.varint();
+        return;
+      case WIRE_FIXED64:
+        this.pos += 8;
+        return;
+      case WIRE_LENGTH:
+        this.bytes();
+        return;
+      case WIRE_FIXED32:
+        this.pos += 4;
+        return;
+    }
+    throw new Error(`unsupported wire type ${wireType}`);
+  }
+};
+
+// src/messages.ts
+var AgentCapabilities = {
+  ReportsStatus: 1,
+  AcceptsRemoteConfig: 2,
+  ReportsEffectiveConfig: 4,
+  ReportsHealth: 2048,
+  ReportsRemoteConfig: 4096,
+  ReportsHeartbeat: 8192
+};
+var AgentToServerFlags = { RequestInstanceUid: 1 };
+var ServerToAgentFlags = { ReportFullState: 1 };
+var RemoteConfigStatus = /* @__PURE__ */ ((RemoteConfigStatus2) => {
+  RemoteConfigStatus2[RemoteConfigStatus2["Unset"] = 0] = "Unset";
+  RemoteConfigStatus2[RemoteConfigStatus2["Applied"] = 1] = "Applied";
+  RemoteConfigStatus2[RemoteConfigStatus2["Applying"] = 2] = "Applying";
+  RemoteConfigStatus2[RemoteConfigStatus2["Failed"] = 3] = "Failed";
+  return RemoteConfigStatus2;
+})(RemoteConfigStatus || {});
+var ServerErrorType = /* @__PURE__ */ ((ServerErrorType2) => {
+  ServerErrorType2[ServerErrorType2["Unknown"] = 0] = "Unknown";
+  ServerErrorType2[ServerErrorType2["BadRequest"] = 1] = "BadRequest";
+  ServerErrorType2[ServerErrorType2["Unavailable"] = 2] = "Unavailable";
+  return ServerErrorType2;
+})(ServerErrorType || {});
+function writeAnyValue(w, value) {
+  if (typeof value === "string") {
+    w.string(1, value);
+  } else if (typeof value === "boolean") {
+    w.bool(2, value);
+  } else if (typeof value === "number") {
+    if (Number.isInteger(value) && value >= 0) {
+      if (value !== 0) w.tag(3, WIRE_VARINT).varint(value);
+    } else {
+      w.double(4, value);
+    }
+  } else {
+    w.message(5, (array) => {
+      for (const item of value) array.message(1, (v) => v.string(1, item), true);
+    });
+  }
+}
+function writeAttributes(w, field, attrs) {
+  for (const [key, value] of Object.entries(attrs)) {
+    w.message(field, (kv) => {
+      kv.string(1, key);
+      kv.message(2, (v) => writeAnyValue(v, value), true);
+    });
+  }
+}
+function encodeAgentToServer(msg) {
+  const w = new Writer();
+  w.bytes(1, msg.instanceUid);
+  w.uint(2, msg.sequenceNum);
+  if (msg.agentDescription) {
+    const description = msg.agentDescription;
+    w.message(3, (d) => {
+      writeAttributes(d, 1, description.identifying);
+      writeAttributes(d, 2, description.nonIdentifying);
+    });
+  }
+  w.uint(4, msg.capabilities);
+  if (msg.remoteConfigStatus) {
+    const status = msg.remoteConfigStatus;
+    w.message(7, (s) => {
+      s.bytes(1, status.lastRemoteConfigHash);
+      s.uint(2, status.status);
+      if (status.errorMessage) s.string(3, status.errorMessage);
+    });
+  }
+  if (msg.agentDisconnect) w.message(9, () => {
+  }, true);
+  w.uint(10, msg.flags ?? 0);
+  if (msg.customCapabilities?.length) {
+    const capabilities = msg.customCapabilities;
+    w.message(12, (c) => {
+      for (const capability of capabilities) c.string(1, capability);
+    });
+  }
+  return w.finish();
+}
+function each(buf, handle) {
+  const r = new Reader(buf);
+  while (!r.done()) {
+    const { field, wireType } = r.tag();
+    if (!handle(field, wireType, r)) r.skip(wireType);
+  }
+}
+function decodeConfigObject(buf) {
+  const object = { body: new Uint8Array(), contentType: "" };
+  each(buf, (field, wireType, r) => {
+    if (wireType !== WIRE_LENGTH) return false;
+    if (field === 1) object.body = r.bytes().slice();
+    else if (field === 2) object.contentType = r.string();
+    else return false;
+    return true;
+  });
+  return object;
+}
+function decodeRemoteConfig(buf) {
+  const config = { configMap: {}, configHash: new Uint8Array() };
+  each(buf, (field, wireType, r) => {
+    if (wireType !== WIRE_LENGTH) return false;
+    if (field === 2) {
+      config.configHash = r.bytes().slice();
+      return true;
+    }
+    if (field !== 1) return false;
+    each(r.bytes(), (mapField, mapWire, mapReader) => {
+      if (mapField !== 1 || mapWire !== WIRE_LENGTH) return false;
+      let key = "";
+      let value = { body: new Uint8Array(), contentType: "" };
+      each(mapReader.bytes(), (entryField, entryWire, entryReader) => {
+        if (entryWire !== WIRE_LENGTH) return false;
+        if (entryField === 1) key = entryReader.string();
+        else if (entryField === 2) value = decodeConfigObject(entryReader.bytes());
+        else return false;
+        return true;
+      });
+      config.configMap[key] = value;
+      return true;
+    });
+    return true;
+  });
+  return config;
+}
+function decodeServerToAgent(buf) {
+  const msg = { flags: 0, capabilities: 0 };
+  each(buf, (field, wireType, r) => {
+    switch (field) {
+      case 1:
+        if (wireType !== WIRE_LENGTH) return false;
+        msg.instanceUid = r.bytes().slice();
+        return true;
+      case 2: {
+        if (wireType !== WIRE_LENGTH) return false;
+        const error = { type: 0 /* Unknown */, message: "" };
+        each(r.bytes(), (f, w, er) => {
+          if (f === 1 && w === WIRE_VARINT) error.type = er.varint();
+          else if (f === 2 && w === WIRE_LENGTH) error.message = er.string();
+          else if (f === 3 && w === WIRE_LENGTH) {
+            each(er.bytes(), (rf, rw, rr) => {
+              if (rf !== 1 || rw !== WIRE_VARINT) return false;
+              error.retryAfterMs = rr.varint() / 1e6;
+              return true;
+            });
+          } else return false;
+          return true;
+        });
+        msg.errorResponse = error;
+        return true;
+      }
+      case 3:
+        if (wireType !== WIRE_LENGTH) return false;
+        msg.remoteConfig = decodeRemoteConfig(r.bytes());
+        return true;
+      case 4:
+        if (wireType !== WIRE_LENGTH) return false;
+        each(r.bytes(), (f, w, cr) => {
+          if (f !== 2 || w !== WIRE_LENGTH) return false;
+          each(cr.bytes(), (of, ow, or) => {
+            if (of !== 4 || ow !== WIRE_VARINT) return false;
+            msg.heartbeatIntervalSeconds = or.varint();
+            return true;
+          });
+          return true;
+        });
+        return true;
+      case 6:
+        if (wireType !== WIRE_VARINT) return false;
+        msg.flags = r.varint();
+        return true;
+      case 7:
+        if (wireType !== WIRE_VARINT) return false;
+        msg.capabilities = r.varint();
+        return true;
+      case 8:
+        if (wireType !== WIRE_LENGTH) return false;
+        each(r.bytes(), (f, w, ir) => {
+          if (f !== 1 || w !== WIRE_LENGTH) return false;
+          msg.newInstanceUid = ir.bytes().slice();
+          return true;
+        });
+        return true;
+      case 11: {
+        if (wireType !== WIRE_LENGTH) return false;
+        const custom = { capability: "", type: "", data: new Uint8Array() };
+        each(r.bytes(), (f, w, cr) => {
+          if (w !== WIRE_LENGTH) return false;
+          if (f === 1) custom.capability = cr.string();
+          else if (f === 2) custom.type = cr.string();
+          else if (f === 3) custom.data = cr.bytes().slice();
+          else return false;
+          return true;
+        });
+        msg.customMessage = custom;
+        return true;
+      }
+    }
+    return false;
+  });
+  return msg;
+}
+function encodeServerToAgent(msg) {
+  const w = new Writer();
+  if (msg.instanceUid) w.bytes(1, msg.instanceUid);
+  if (msg.remoteConfig) {
+    const config = msg.remoteConfig;
+    w.message(3, (rc) => {
+      rc.message(1, (map) => {
+        for (const [key, object] of Object.entries(config.configMap)) {
+          map.message(1, (entry) => {
+            entry.string(1, key);
+            entry.message(2, (o) => o.bytes(1, object.body).string(2, object.contentType), true);
+          });
+        }
+      });
+      rc.bytes(2, config.configHash);
+    });
+  }
+  if (msg.heartbeatIntervalSeconds) {
+    const seconds = msg.heartbeatIntervalSeconds;
+    w.message(4, (cs) => cs.message(2, (o) => o.uint(4, seconds)));
+  }
+  w.uint(6, msg.flags);
+  w.uint(7, msg.capabilities);
+  if (msg.newInstanceUid) w.message(8, (id) => id.bytes(1, msg.newInstanceUid));
+  return w.finish();
+}
+
+// src/client.ts
+var MIN_POLL_INTERVAL_MS = 3e4;
+var MAX_BACKOFF_MS = 30 * 6e4;
+var FIRST_BACKOFF_MS = 3e4;
+function uuidString(bytes) {
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join(
+    ""
+  );
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function sameBytes(a, b) {
+  if (!a || !b || a.length !== b.length) return false;
+  return a.every((v, i) => v === b[i]);
+}
+var OpampHttpClient = class {
+  constructor(options) {
+    this.options = options;
+    this.uid = options.instanceUid;
+    this.intervalMs = Math.max(
+      options.defaultPollIntervalMs ?? 3e5,
+      MIN_POLL_INTERVAL_MS
+    );
+    this.fetchImpl = options.fetchImpl ?? ((...args) => fetch(...args));
+    if (options.appliedConfigHash?.length) {
+      this.status = {
+        lastRemoteConfigHash: options.appliedConfigHash,
+        status: 1 /* Applied */
+      };
+    }
+  }
+  options;
+  uid;
+  sequenceNum = 0;
+  status;
+  intervalMs;
+  backoffMs = 0;
+  timer = null;
+  inFlight = null;
+  stopped = true;
+  lastPollAt = 0;
+  fetchImpl;
+  start() {
+    if (!this.stopped) return;
+    this.stopped = false;
+    void this.poll();
+  }
+  stop() {
+    this.stopped = true;
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+  pollIntervalMs() {
+    return this.intervalMs;
+  }
+  millisSinceLastPoll() {
+    return this.lastPollAt === 0 ? Infinity : Date.now() - this.lastPollAt;
+  }
+  /** Polls now unless a poll is running or the client is backing off after an error. */
+  poll() {
+    if (this.stopped) return Promise.resolve();
+    if (this.inFlight) return this.inFlight;
+    if (this.backoffMs > 0 && this.timer !== null) return Promise.resolve();
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.inFlight = this.exchange().finally(() => {
+      this.inFlight = null;
+    });
+    return this.inFlight;
+  }
+  /** Polls with the current description even if a poll is under way, e.g. right after a targeting attribute changed. */
+  async refresh() {
+    if (this.inFlight) await this.inFlight;
+    await this.poll();
+  }
+  schedule(delayMs) {
+    if (this.stopped) return;
+    if (this.timer !== null) clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.poll();
+    }, delayMs);
+  }
+  async exchange() {
+    const controller = new AbortController();
+    const timer = setTimeout(
+      () => controller.abort(),
+      this.options.requestTimeoutMs ?? 1e4
+    );
+    try {
+      await this.exchangeWithSignal(controller.signal);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async exchangeWithSignal(signal) {
+    this.lastPollAt = Date.now();
+    let response;
+    try {
+      response = await this.send(
+        {
+          instanceUid: this.uid,
+          sequenceNum: this.sequenceNum++,
+          agentDescription: this.options.describe(),
+          capabilities: this.options.capabilities,
+          remoteConfigStatus: this.status,
+          customCapabilities: this.options.customCapabilities
+        },
+        signal
+      );
+    } catch {
+      this.options.onUnavailable?.();
+      this.backOff(null);
+      return;
+    }
+    if (response.status === 404 || response.status === 405 || response.status === 501) {
+      this.stop();
+      this.options.onUnsupported?.();
+      return;
+    }
+    if (response.status === 401 || response.status === 403) {
+      this.stop();
+      this.options.onUnauthorized?.();
+      return;
+    }
+    if (response.status === 413) {
+      this.backoffMs = 0;
+      this.schedule(this.intervalMs);
+      return;
+    }
+    let message = null;
+    try {
+      message = decodeServerToAgent(
+        new Uint8Array(await response.arrayBuffer())
+      );
+    } catch {
+      message = null;
+    }
+    if (response.status === 429 || response.status >= 500 || message?.errorResponse?.type === 2 /* Unavailable */) {
+      const header = Number(response.headers.get("Retry-After"));
+      const retryAfter = Number.isFinite(header) && header > 0 ? header * 1e3 : message?.errorResponse?.retryAfterMs ?? null;
+      this.backOff(retryAfter);
+      return;
+    }
+    if (!response.ok || !message) {
+      this.backOff(null);
+      return;
+    }
+    if (this.stopped) return;
+    this.backoffMs = 0;
+    this.options.onConnected?.();
+    this.handle(message);
+  }
+  handle(message) {
+    if (message.newInstanceUid?.length === 16) {
+      this.uid = message.newInstanceUid;
+      this.options.onInstanceUidChange?.(this.uid);
+    }
+    if (message.heartbeatIntervalSeconds) {
+      const next = Math.max(
+        message.heartbeatIntervalSeconds * 1e3,
+        MIN_POLL_INTERVAL_MS
+      );
+      if (next !== this.intervalMs) {
+        this.intervalMs = next;
+        this.options.onHeartbeatChange?.(message.heartbeatIntervalSeconds);
+      }
+    }
+    let reportNow = false;
+    if (message.remoteConfig && !sameBytes(
+      message.remoteConfig.configHash,
+      this.status?.lastRemoteConfigHash
+    )) {
+      let result;
+      try {
+        result = this.options.onRemoteConfig(message.remoteConfig);
+      } catch (err) {
+        result = {
+          applied: false,
+          errorMessage: err instanceof Error ? err.message : String(err)
+        };
+      }
+      this.status = result.applied ? {
+        lastRemoteConfigHash: message.remoteConfig.configHash,
+        status: 1 /* Applied */
+      } : {
+        lastRemoteConfigHash: message.remoteConfig.configHash,
+        status: 3 /* Failed */,
+        errorMessage: result.errorMessage
+      };
+      reportNow = true;
+    }
+    if (reportNow || (message.flags & ServerToAgentFlags.ReportFullState) !== 0) {
+      this.schedule(0);
+      return;
+    }
+    this.schedule(this.intervalMs);
+  }
+  backOff(retryAfterMs) {
+    this.backoffMs = retryAfterMs ?? Math.min(
+      this.backoffMs > 0 ? this.backoffMs * 2 : FIRST_BACKOFF_MS,
+      MAX_BACKOFF_MS
+    );
+    this.schedule(Math.max(this.backoffMs, 1e3));
+  }
+  send(message, signal) {
+    return this.fetchImpl(this.options.endpoint, {
+      method: "POST",
+      signal,
+      headers: {
+        ...this.options.headers,
+        "Content-Type": "application/x-protobuf",
+        "OpAMP-Instance-UID": uuidString(this.uid)
+      },
+      body: encodeAgentToServer(message)
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentCapabilities,
+  AgentToServerFlags,
+  OpampHttpClient,
+  RemoteConfigStatus,
+  ServerErrorType,
+  ServerToAgentFlags,
+  decodeServerToAgent,
+  encodeAgentToServer,
+  encodeServerToAgent,
+  uuidString
+});
+//# sourceMappingURL=index.js.map