Retry with backoff

README.md

@@ -1,4 +1,4 @@
-# effection-contrib
+# [effection-contrib](https://effection-contrib.deno.dev/)
 
 This repository contains a collection of contributions by the community. This
 repository automatically publishes to JSR and NPM. All packages that were used
@@ -8,7 +8,14 @@ more than a few times are welcome.
 
 1. Create a directory
 2. Add a deno.json file with
-   `{ "name": "@effection-contrib/<you_package_name>", version: "0.1.0", "exports": "./mod.ts", "license": "MIT" }`
+```json
+{
+   "name": "@effection-contrib/<you_package_name>",
+   "version": "0.1.0",
+   "exports": "./mod.ts",
+   "license": "MIT"
+}
+```
 3. Add a README.md (the first sentence of the README will be used as the
    description)
 4. Add your source code and export it from `mod.ts`
@@ -17,6 +24,6 @@ more than a few times are welcome.
 
 ## To publish a new project
 
-1. Member of [jsr.io/@effection-contrib](https://jsr.io/@effection-contrib) has
-   too add that project to the scope
-2. It should be publish on next merge to main
+1. A member of [jsr.io/@effection-contrib](https://jsr.io/@effection-contrib) has
+   to add that project to the scope
+2. Your new package will be published on the next merge to main

deno.json

@@ -3,7 +3,6 @@
     "dev": "deno run  -A --watch www/main.ts"
   },
   "imports": {
-    "effection": "npm:[email protected]",
     "effection-www/": "https://raw.githubusercontent.com/thefrontside/effection/4982887c1677b847d256402e8709f2b1d49437e6/www/",
     "revolution": "https://deno.land/x/[email protected]/mod.ts",
     "revolution/jsx-runtime": "https://deno.land/x/[email protected]/jsx-runtime.ts",
@@ -38,7 +37,8 @@
     "./deno-deploy",
     "./task-buffer",
     "./tinyexec",
-    "./websocket"
+    "./websocket",
+    "./retry-backoff"
   ],
   "deploy": {
     "project": "aa1dbfaa-d7c1-49d7-b514-69e1d8344f95",

retry-backoff/README.md

@@ -0,0 +1,37 @@
+# retry-backoff
+
+Retry operations with incremental backoff.
+
+---
+
+There's a default timeout set to 30 seconds. If you'd like to set a different
+timeout, you'll need to either pass in options to `useRetryWithBackoff`:
+
+```js
+import { main } from "effection";
+import { useRetryWithBackoff } from "@effection-contrib/retry-backoff";
+
+await main(function* () {
+  yield* useRetryWithBackoff(function* () {
+    yield* call(fetch("https://foo.bar/"));
+  }, { timeout: 45_000 });
+});
+```
+
+Or initialize the context so that the same timeout can be applied to all of your
+retry operations:
+
+```js
+import { main } from "effection";
+import {
+  initRetryWithBackoff,
+  useRetryWithBackoff,
+} from "@effection-contrib/retry-backoff";
+
+await main(function* () {
+  yield* initRetryWithBackoff({ timeout: 45_000 });
+  yield* retryWithBackoff(function* () {
+    yield* call(fetch("https://foo.bar/"));
+  });
+});
+```

retry-backoff/deno.json

@@ -0,0 +1,6 @@
+{
+  "name": "@effection-contrib/retry-backoff",
+  "version": "0.1.0",
+  "exports": "./mod.ts",
+  "license": "MIT"
+}

retry-backoff/mod.ts

@@ -0,0 +1,4 @@
+export {
+  useRetryWithBackoff,
+  initRetryWithBackoff,
+} from './retry-backoff.ts';

retry-backoff/retry-backoff.test.ts

@@ -0,0 +1,39 @@
+import { run } from "npm:[email protected]";
+import { describe, it } from "bdd";
+import { expect } from "expect";
+import { useRetryWithBackoff } from "./retry-backoff.ts"
+
+describe("RetryBackoff", () => {
+  it("retries operation and returns output if operation finishes on time", async () => {
+    await run(function* () {
+      let attempts = 0;
+      let result = 0;
+      yield* useRetryWithBackoff(function* () {
+        if (attempts < 2) {
+          attempts++;
+          throw new Error("operation failed");
+        } else {
+          result = 1;
+        }
+      }, { timeout: 2_000 });
+      expect(attempts).toBe(2);
+      expect(result).toBe(1);
+    })
+  });
+
+  it("retries operation and handles timeout when operation exceeds limit", async () => {
+    await run(function* () {
+      let attempts = 0;
+      let result = 0;
+      yield* useRetryWithBackoff(function* () {
+        if (attempts < 2) {
+          attempts++;
+          throw new Error("operation failed");
+        } else {
+          result = 1;
+        }
+      }, { timeout: 500 });
+      expect(result).toBe(0);
+    })
+  });
+});

retry-backoff/retry-backoff.ts

@@ -0,0 +1,87 @@
+import {
+  createContext,
+  type Context as ContextType,
+  type Operation,
+  race,
+  sleep,
+} from "npm:[email protected]";
+import prettyMilliseconds from "npm:[email protected]";
+
+interface UseRetryBackoffOptions {
+  timeout?: number;
+}
+
+interface RetryWithContextDefaults {
+  timeout: number;
+}
+
+const RetryBackoffContext = createContext<RetryWithContextDefaults>(
+  "retry-with-context",
+  {
+    timeout: 30_000,
+  }
+);
+
+export function* useRetryWithBackoff<T> (
+  fn: () => Operation<T>,
+  options?: UseRetryBackoffOptions,
+) {
+  const defaults = yield* RetryBackoffContext.expect();
+  const _options = {
+    ...defaults,
+    ...options,
+  };
+
+  let attempt = -1;
+  let name = fn.name || "unknown";
+
+  function* body() {
+    while (true) {
+      try {
+        const result = yield* fn();
+        if (attempt !== -1) {
+          console.log(`Operation[${name}] succeeded after ${attempt + 2} retry.`);
+        }
+        return result;
+      } catch {
+        // https://aws.amazon.com/ru/blogs/architecture/exponential-backoff-and-jitter/
+        const backoff = Math.pow(2, attempt) * 1000;
+        const delayMs = Math.round((backoff * (1 + Math.random())) / 2);
+        console.log(`Operation[${name}] failed, will retry in ${prettyMilliseconds(delayMs)}.`);
+        yield* sleep(delayMs);
+        attempt++;
+      }
+    }
+  }
+
+  function* timeout() {
+    yield* sleep(_options.timeout);
+    console.log(`Operation[${name}] timedout after ${attempt + 2}`);
+  }
+
+  yield* race([
+    body(),
+    timeout(),
+  ]);
+}
+
+export function* initRetryWithBackoff(
+  defaults: RetryWithContextDefaults,
+) {
+  // deno-lint-ignore require-yield
+  function* init(): Operation<RetryWithContextDefaults> {
+    return defaults;
+  }
+
+  return yield* ensureContext(
+    RetryBackoffContext,
+    init(),
+  );
+}
+
+function* ensureContext<T>(Context: ContextType<T>, init: Operation<T>) {
+  if (!(yield* Context.get())) {
+    yield* Context.set(yield* init);
+  }
+  return yield* Context.expect();
+}