@fly/edge
Version:
Fly's TypeScript Edge
225 lines (224 loc) • 26.6 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports._internal = exports.syncBackends = void 0;
/**
* A fetch function load balancer. Distributes requests to a set of backends; attempts to
* send requests to most recently healthy backends using a 2 random (pick two healthiest,
* randomize which gets requests).
*
* If all backends are healthy, tries to evenly distribute requests as much as possible.
*
* When backends return server errors (500-599) it retries idempotent requests
* until it gets a good response, or all backends have been tried.
*
* @param backends fetch functions for each backend to balance accross
* @returns a function that behaves just like fetch, with a `.backends` property for
* retrieving backend stats.
*/
function balancer(backends) {
let tracked = syncBackends([], backends);
const fn = async function fetchBalancer(req, init) {
if (typeof req === "string") {
req = new Request(req);
}
const url = new URL(req.url);
let trackLatency = url.pathname === "/"; // this would be configurable in real life
const attempted = new Set();
while (attempted.size < tracked.length) {
let backend = null;
const [backendA, backendB] = chooseBackends(tracked, attempted);
if (!backendA) {
return new Response("No backend available", { status: 502 });
}
if (!backendB) {
backend = backendA;
}
else {
// randomize between 2 good candidates
backend = (Math.floor(Math.random() * 2) == 0) ? backendA : backendB;
}
const promise = backend.proxy(req, init);
if (backend.scoredRequestCount != backend.requestCount) {
// fixup score
// this should be relatively concurrent with the fetch promise
scoreHealth(backend);
}
backend.requestCount += 1;
attempted.add(backend);
const start = Date.now();
let resp;
try {
resp = await promise;
}
catch (e) {
resp = proxyError;
trackLatency = false;
}
setFixedArrayValue(backend.statuses, resp.status, 10, backend.requestCount);
if (trackLatency) {
const ms = Date.now() - start;
setFixedArrayValue(backend.latencies, ms, 10, backend.requestCount);
scoreLatency(backend);
}
// save backend stats every 3s
/*if(!backend.lastSaved || (Date.now() - backend.lastSaved) > 3000){
}*/
if (resp.status >= 500 && resp.status < 600) {
backend.lastError = Date.now();
// always recompute score on errors
scoreHealth(backend);
// clear out response to trigger retry
if (canRetry(req, resp)) {
continue;
}
}
return resp;
}
return proxyError;
};
const balancer = Object.assign(fn, {
backends: tracked,
updateBackends: (backends) => balancer.backends = tracked = syncBackends(tracked, backends)
});
return balancer;
}
exports.default = balancer;
const proxyError = new Response("couldn't connect to origin", { status: 502 });
function syncBackends(current, replacements) {
const idx = new Map();
for (const b of current) {
idx.set(b.proxy, b);
}
const updated = [];
for (const fn of replacements) {
if (typeof fn !== "function") {
throw Error("Backend must be a fetch like function");
}
const b = idx.get(fn) || {
proxy: fn,
requestCount: 0,
scoredRequestCount: 0,
statuses: Array(10),
latencies: Array(10),
lastError: 0,
healthScore: 1,
latencyScore: 1,
errorCount: 0
};
updated.push(b);
}
return updated;
}
exports.syncBackends = syncBackends;
// compute a backend health score with time + status codes
function scoreHealth(backend, errorBasis) {
if (typeof errorBasis !== "number" && !errorBasis)
errorBasis = Date.now();
const timeSinceError = (errorBasis - backend.lastError);
const statuses = backend.statuses;
const timeWeight = (backend.lastError === 0 && 0) ||
((timeSinceError < 1000) && 1) ||
((timeSinceError < 3000) && 0.8) ||
((timeSinceError < 5000) && 0.3) ||
((timeSinceError < 10000) && 0.1) ||
0;
if (statuses.length == 0)
return 0;
let requests = 0;
let errors = 0;
for (let i = 0; i < statuses.length; i++) {
const status = statuses[i];
if (status && !isNaN(status)) {
requests += 1;
if (status >= 500 && status < 600) {
errors += 1;
}
}
}
const healthScore = (1 - (timeWeight * (errors / requests)));
backend.healthScore = healthScore;
backend.scoredRequestCount = backend.requestCount;
return healthScore;
}
function scoreLatency(backend) {
let total = 0;
for (const l of backend.latencies) {
total += l;
}
const avgLatency = total / backend.latencies.length;
backend.latencyScore = orderOfMagnitude(avgLatency);
return backend.latencyScore;
}
function canRetry(req, resp) {
if (resp && resp.status < 500)
return false; // don't retry normal boring errors or success
if (req.method == "GET" || req.method == "HEAD")
return true;
return false;
}
function chooseBackends(backends, attempted) {
let b1;
let b2;
for (let i = 0; i < backends.length; i++) {
const b = backends[i];
if (attempted && attempted.has(b))
continue;
if (!b1) {
b1 = b;
continue;
}
if (!b2) {
b2 = b;
continue;
}
const old1 = b1;
b1 = bestBackend(b, b1);
if (old1 != b1) {
// b1 got replaced, make sure it's not better
b2 = bestBackend(old1, b2);
}
else {
b2 = bestBackend(b, b2);
}
}
// if two best backends have different latency, use only the fastest one
if (b1 && b2 && b1.latencyScore < b2.latencyScore)
return [b1];
if (b1 && b2 && b2.latencyScore < b1.latencyScore)
return [b2];
return [b1, b2];
}
function bestBackend(b1, b2) {
// simple health check before we compare latency
if (b1.healthScore < 0.85 && b2.healthScore > 0.85) {
return b2;
}
if (b2.healthScore < 0.85 && b1.healthScore > 0.85) {
return b1;
}
if (b1.latencyScore < b2.latencyScore ||
(b1.latencyScore == b2.latencyScore && b1.requestCount < b2.requestCount)) {
return b1;
}
return b2;
}
function setFixedArrayValue(arr, value, maxLength, totalCount) {
if (arr.length < maxLength) {
arr.push(value);
}
else {
arr[(totalCount - 1) % arr.length] = value;
}
}
function orderOfMagnitude(value) {
//https://stackoverflow.com/questions/23917074/javascript-flooring-number-to-order-of-magnitude
const order = Math.floor(Math.log(value) / Math.LN10);
return Math.pow(10, order);
}
/** @private */
exports._internal = {
chooseBackends,
scoreHealth,
scoreLatency
};
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"balancer.js","sourceRoot":"","sources":["../../src/balancer.ts"],"names":[],"mappings":"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","sourcesContent":["import { FetchFunction } from \"./fetch\";\n\n/**\n * A fetch function load balancer. Distributes requests to a set of backends; attempts to \n * send requests to most recently healthy backends using a 2 random (pick two healthiest, \n * randomize which gets requests).\n * \n * If all backends are healthy, tries to evenly distribute requests as much as possible.\n * \n * When backends return server errors (500-599) it retries idempotent requests\n *  until it gets a good response, or all backends have been tried.\n * \n * @param backends fetch functions for each backend to balance accross\n * @returns a function that behaves just like fetch, with a `.backends` property for \n * retrieving backend stats.\n */\nexport default function balancer(backends: FetchFunction[]) {\n  let tracked = syncBackends([], backends)\n\n  const fn = async function fetchBalancer(req: RequestInfo, init?: RequestInit | undefined): Promise<Response> {\n    if (typeof req === \"string\") {\n      req = new Request(req)\n    }\n    const url = new URL(req.url)\n    let trackLatency = url.pathname === \"/\" // this would be configurable in real life\n    const attempted = new Set<Backend>()\n    while (attempted.size < tracked.length) {\n      let backend: Backend | null = null\n      const [backendA, backendB] = chooseBackends(tracked, attempted)\n\n      if (!backendA) {\n        return new Response(\"No backend available\", { status: 502 })\n      }\n      if (!backendB) {\n        backend = backendA\n      } else {\n        // randomize between 2 good candidates\n        backend = (Math.floor(Math.random() * 2) == 0) ? backendA : backendB\n      }\n\n      const promise = backend.proxy(req, init)\n      if (backend.scoredRequestCount != backend.requestCount) {\n        // fixup score\n        // this should be relatively concurrent with the fetch promise\n        scoreHealth(backend)\n      }\n      backend.requestCount += 1\n      attempted.add(backend)\n\n      const start = Date.now()\n      let resp: Response\n      try {\n        resp = await promise\n      } catch (e) {\n        resp = proxyError\n        trackLatency = false\n      }\n      setFixedArrayValue(backend.statuses, resp.status, 10, backend.requestCount)\n\n      if(trackLatency){\n        const ms = Date.now() - start\n        setFixedArrayValue(backend.latencies, ms, 10, backend.requestCount)\n        scoreLatency(backend)\n      }\n\n      // save backend stats every 3s\n      /*if(!backend.lastSaved || (Date.now() - backend.lastSaved) > 3000){\n\n      }*/\n\n      if (resp.status >= 500 && resp.status < 600) {\n        backend.lastError = Date.now()\n        // always recompute score on errors\n        scoreHealth(backend)\n\n        // clear out response to trigger retry\n        if (canRetry(req, resp)) {\n          continue\n        }\n      }\n\n      return resp\n    }\n\n    return proxyError\n  }\n\n  const balancer = Object.assign(fn, {\n    backends: tracked,\n    updateBackends: (backends: FetchFunction[]) => balancer.backends = tracked = syncBackends(tracked, backends)\n  })\n\n  return balancer;\n}\nconst proxyError = new Response(\"couldn't connect to origin\", { status: 502 })\n\nexport function syncBackends(current: Backend[], replacements: FetchFunction[]){\n  const idx = new Map<FetchFunction, Backend>()\n  for(const b of current){\n    idx.set(b.proxy, b)\n  }\n\n  const updated: Backend[] = []\n\n  for(const fn of replacements){\n    if (typeof fn !== \"function\") {\n      throw Error(\"Backend must be a fetch like function\")\n    }\n    const b = idx.get(fn) || {\n      proxy: fn,\n      requestCount: 0,\n      scoredRequestCount: 0,\n      statuses: Array<number>(10),\n      latencies: Array<number>(10),\n      lastError: 0,\n      healthScore: 1,\n      latencyScore: 1,\n      errorCount: 0\n    }\n\n    updated.push(b)\n  }\n  return updated;\n}\n\n/**\n * Represents a backend with health and statistics.\n */\nexport interface Backend {\n  proxy: (req: RequestInfo, init?: RequestInit | undefined) => Promise<Response>,\n  requestCount: 0,\n  scoredRequestCount: 0,\n  statuses: number[],\n  latencies: number[],\n  lastError: number,\n  healthScore: number,\n  latencyScore: number,\n  errorCount: 0,\n  lastSaved?: number\n}\n// compute a backend health score with time + status codes\nfunction scoreHealth(backend: Backend, errorBasis?: number) {\n  if (typeof errorBasis !== \"number\" && !errorBasis) errorBasis = Date.now()\n\n  const timeSinceError = (errorBasis - backend.lastError)\n  const statuses = backend.statuses\n  const timeWeight = (backend.lastError === 0 && 0) ||\n    ((timeSinceError < 1000) && 1) ||\n    ((timeSinceError < 3000) && 0.8) ||\n    ((timeSinceError < 5000) && 0.3) ||\n    ((timeSinceError < 10000) && 0.1) ||\n    0;\n  if (statuses.length == 0) return 0\n  let requests = 0\n  let errors = 0\n  for (let i = 0; i < statuses.length; i++) {\n    const status = statuses[i]\n    if (status && !isNaN(status)) {\n      requests += 1\n      if (status >= 500 && status < 600) {\n        errors += 1\n      }\n    }\n  }\n  const healthScore = (1 - (timeWeight * (errors / requests)))\n  backend.healthScore = healthScore\n  backend.scoredRequestCount = backend.requestCount\n  return healthScore\n}\nfunction scoreLatency(backend: Backend){\n  let total = 0\n  for(const l of backend.latencies){\n    total += l\n  }\n  const avgLatency = total / backend.latencies.length\n\n  backend.latencyScore = orderOfMagnitude(avgLatency)\n  return backend.latencyScore\n}\nfunction canRetry(req: Request, resp: Response) {\n  if (resp && resp.status < 500) return false // don't retry normal boring errors or success\n  if (req.method == \"GET\" || req.method == \"HEAD\") return true\n  return false\n}\n\nfunction chooseBackends(backends: Backend[], attempted?: Set<Backend>) {\n  let b1: Backend | undefined\n  let b2: Backend | undefined\n  for (let i = 0; i < backends.length; i++) {\n    const b = backends[i]\n    if (attempted && attempted.has(b)) continue;\n\n    if (!b1) {\n      b1 = b\n      continue\n    }\n    if (!b2) {\n      b2 = b\n      continue\n    }\n\n    const old1 = b1\n    b1 = bestBackend(b, b1)\n\n    if (old1 != b1) {\n      // b1 got replaced, make sure it's not better\n      b2 = bestBackend(old1, b2)\n    } else {\n      b2 = bestBackend(b, b2)\n    }\n  }\n\n  // if two best backends have different latency, use only the fastest one\n  if(b1 && b2 && b1.latencyScore < b2.latencyScore) return [b1]\n  if(b1 && b2 && b2.latencyScore < b1.latencyScore) return [b2]\n  \n  return [b1, b2]\n}\n\nfunction bestBackend(b1: Backend, b2: Backend) {\n  // simple health check before we compare latency\n  if(b1.healthScore < 0.85 && b2.healthScore > 0.85){\n    return b2\n  }\n  if(b2.healthScore < 0.85 && b1.healthScore > 0.85){\n    return b1\n  }\n  if (\n    b1.latencyScore < b2.latencyScore ||\n    (b1.latencyScore == b2.latencyScore && b1.requestCount < b2.requestCount)\n  ) {\n    return b1\n  }\n  return b2\n}\n\nfunction setFixedArrayValue<T>(arr: T[], value: T, maxLength: number, totalCount: number){\n  if(arr.length < maxLength){\n    arr.push(value)\n  }else{\n    arr[(totalCount- 1) % arr.length] = value\n  }\n}\n\nfunction orderOfMagnitude(value: number){\n  //https://stackoverflow.com/questions/23917074/javascript-flooring-number-to-order-of-magnitude\n  const order = Math.floor(Math.log(value) / Math.LN10)\n  return Math.pow(10, order)\n}\n\n/** @private */\nexport const _internal = {\n  chooseBackends,\n  scoreHealth,\n  scoreLatency\n}"]}