The only tool you need to know what is happening and how to fix it.
Go alertingexception-trackerissue-trackinglogsmetricsmonitoringobservability-platformopen-telemetryotelsession-replaytelemetrytraces
Reliable Apps Crash Blog Post
narrow-adventure3fb6cafb84b6
diff --git a/diagrams/blog/reliable-apps-crash-so-why-does-go-recover-panics/boundary-ladder.dot b/diagrams/blog/reliable-apps-crash-so-why-does-go-recover-panics/boundary-ladder.dotnew file mode 100644index 00000000..ce34064a--- /dev/null+++ b/diagrams/blog/reliable-apps-crash-so-why-does-go-recover-panics/boundary-ladder.dot@@ -0,0 +1,46 @@+// Recovery boundaries from narrow to broad, and where a panic goes when the+// boundary it reached cannot own every side effect. Render:+// dot -Tsvg boundary-ladder.dot -o boundary-ladder.svg+// Output belongs in website/public/blog/reliable-apps-crash-so-why-does-go-recover-panics/.+// Palette matches the Traceway dark theme (app/globals.css).+digraph boundary_ladder {+ bgcolor="transparent";+ rankdir=TB;+ nodesep=0.34;+ ranksep=0.44;+ pad=0.2;+ fontname="Helvetica";++ node [shape=box, style="rounded,filled", fontname="Helvetica", fontsize=14,+ penwidth=1.3, margin="0.30,0.18",+ color="#283041", fillcolor="#151a24", fontcolor="#f4f6fb"];+ edge [color="#5a6374", penwidth=1.4, arrowsize=0.85,+ fontname="Helvetica", fontsize=11, fontcolor="#8a93a6"];++ panic [label=<<b>a panic starts</b><br/><font color="#ff9a9d" point-size="12">nil pointer · failed type assertion · library bug</font>>,+ color="#ff5a5f", fillcolor="#1b1115"];+ op [label=<<b>operation</b><br/><font color="#8a93a6" point-size="12">roll back the partial mutation before the lock is released</font>>];+ req [label=<<b>request</b><br/><font color="#8a93a6" point-size="12">discard everything the request touched (the net/http default)</font>>];+ job [label=<<b>durable job attempt</b><br/><font color="#8a93a6" point-size="12">fail the attempt, the queue retries from the last committed step</font>>];+ worker [label=<<b>worker</b><br/><font color="#8a93a6" point-size="12">the goroutine catches its own panic, a supervisor goroutine starts a new one</font>>];+ proc [label=<<b>process</b><br/><font color="#ff9a9d" point-size="12">exit with a nonzero status, nothing smaller could be proven safe</font>>,+ color="#ff5a5f", fillcolor="#1b1115"];+ sup [label=<<b>supervisor</b><br/><font color="#7ff0c8" point-size="12">systemd · Docker · kubelet start a clean process, with backoff</font>>,+ color="#22e0a8", fillcolor="#0c1714"];+ ok [label=<<b>recovered</b><br/><font color="#7ff0c8" point-size="12">invariants hold again,<br/>keep serving</font>>,+ color="#22e0a8", fillcolor="#0c1714"];++ panic -> op;+ op -> req [label=" side effects survive it: widen"];+ req -> job [label=" side effects survive it"];+ job -> worker [label=" side effects survive it"];+ worker -> proc [label=" side effects survive it"];+ proc -> sup [label=" exit(1)", color="#ff5a5f", fontcolor="#ff8a8d"];++ { rank=same; job; ok; }+ op -> ok [constraint=false, tailport=e, headport=w, color="#22e0a8", fontcolor="#7ff0c8",+ label="owns every side effect:\lrecover here\l"];+ req -> ok [constraint=false, tailport=e, headport=w, color="#22e0a8"];+ job -> ok [constraint=false, tailport=e, headport=w, color="#22e0a8"];+ worker -> ok [constraint=false, tailport=e, headport=w, color="#22e0a8"];+}diff --git a/diagrams/blog/reliable-apps-crash-so-why-does-go-recover-panics/fonts/inter.sub.woff2 b/diagrams/blog/reliable-apps-crash-so-why-does-go-recover-panics/fonts/inter.sub.woff2new file mode 100644index 00000000..09aec7b8Binary files /dev/null and b/diagrams/blog/reliable-apps-crash-so-why-does-go-recover-panics/fonts/inter.sub.woff2 differdiff --git a/diagrams/blog/reliable-apps-crash-so-why-does-go-recover-panics/fonts/jetbrains-mono-700.sub.woff2 b/diagrams/blog/reliable-apps-crash-so-why-does-go-recover-panics/fonts/jetbrains-mono-700.sub.woff2new file mode 100644index 00000000..3ec21429Binary files /dev/null and b/diagrams/blog/reliable-apps-crash-so-why-does-go-recover-panics/fonts/jetbrains-mono-700.sub.woff2 differdiff --git a/diagrams/blog/reliable-apps-crash-so-why-does-go-recover-panics/recovery-boundaries.drawio b/diagrams/blog/reliable-apps-crash-so-why-does-go-recover-panics/recovery-boundaries.drawionew file mode 100644index 00000000..cf77ff49--- /dev/null+++ b/diagrams/blog/reliable-apps-crash-so-why-does-go-recover-panics/recovery-boundaries.drawio@@ -0,0 +1,100 @@+<mxfile host="app.diagrams.net" version="29.3.6">+ <diagram name="recovery-boundaries" id="recovery-boundaries-1">+ <mxGraphModel dx="0" dy="0" grid="0" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="1200" pageHeight="630" math="0" shadow="0">+ <root>+ <mxCell id="0" />+ <mxCell id="1" parent="0" />++ <mxCell id="bg" parent="1" vertex="1" value="" style="rounded=0;html=0;fillColor=#0a0d14;strokeColor=none;">+ <mxGeometry x="0" y="0" width="1200" height="630" as="geometry" />+ </mxCell>+ <mxCell id="eyebrow" parent="1" vertex="1" value="RECOVERY BOUNDARIES" style="text;html=0;align=left;verticalAlign=middle;fontFamily=Helvetica;fontSize=13;fontColor=#5a6374;strokeColor=none;fillColor=none;">+ <mxGeometry x="60" y="26" width="400" height="24" as="geometry" />+ </mxCell>++ <mxCell id="process" parent="1" vertex="1" value="" style="rounded=1;arcSize=4;html=0;fillColor=#0d1119;strokeColor=#2c3446;strokeWidth=1.5;">+ <mxGeometry x="60" y="70" width="740" height="500" as="geometry" />+ </mxCell>+ <mxCell id="process-t" parent="1" vertex="1" value="process" style="text;html=0;align=center;verticalAlign=middle;fontFamily=Helvetica;fontSize=17;fontStyle=1;fontColor=#c9d0dd;strokeColor=none;fillColor=none;">+ <mxGeometry x="60" y="78" width="740" height="26" as="geometry" />+ </mxCell>++ <mxCell id="worker" parent="1" vertex="1" value="" style="rounded=1;arcSize=4;html=0;fillColor=#10151f;strokeColor=#2f3849;strokeWidth=1.5;">+ <mxGeometry x="106" y="116" width="648" height="408" as="geometry" />+ </mxCell>+ <mxCell id="worker-t" parent="1" vertex="1" value="worker" style="text;html=0;align=center;verticalAlign=middle;fontFamily=Helvetica;fontSize=17;fontStyle=1;fontColor=#c9d0dd;strokeColor=none;fillColor=none;">+ <mxGeometry x="106" y="124" width="648" height="26" as="geometry" />+ </mxCell>++ <mxCell id="job" parent="1" vertex="1" value="" style="rounded=1;arcSize=4;html=0;fillColor=#141a25;strokeColor=#353e50;strokeWidth=1.5;">+ <mxGeometry x="152" y="162" width="556" height="316" as="geometry" />+ </mxCell>+ <mxCell id="job-t" parent="1" vertex="1" value="durable job attempt" style="text;html=0;align=center;verticalAlign=middle;fontFamily=Helvetica;fontSize=17;fontStyle=1;fontColor=#c9d0dd;strokeColor=none;fillColor=none;">+ <mxGeometry x="152" y="170" width="556" height="26" as="geometry" />+ </mxCell>++ <mxCell id="request" parent="1" vertex="1" value="" style="rounded=1;arcSize=4;html=0;fillColor=#181f2b;strokeColor=#3c4557;strokeWidth=1.5;">+ <mxGeometry x="198" y="208" width="464" height="224" as="geometry" />+ </mxCell>+ <mxCell id="request-t" parent="1" vertex="1" value="request" style="text;html=0;align=center;verticalAlign=middle;fontFamily=Helvetica;fontSize=17;fontStyle=1;fontColor=#f4f6fb;strokeColor=none;fillColor=none;">+ <mxGeometry x="198" y="216" width="464" height="26" as="geometry" />+ </mxCell>++ <mxCell id="operation" parent="1" vertex="1" value="" style="rounded=1;arcSize=4;html=0;fillColor=#1b1115;strokeColor=#ff5a5f;strokeWidth=1.5;">+ <mxGeometry x="244" y="254" width="372" height="132" as="geometry" />+ </mxCell>+ <mxCell id="operation-t" parent="1" vertex="1" value="operation" style="text;html=0;align=center;verticalAlign=middle;fontFamily=Helvetica;fontSize=17;fontStyle=1;fontColor=#ff9a9d;strokeColor=none;fillColor=none;">+ <mxGeometry x="244" y="262" width="372" height="26" as="geometry" />+ </mxCell>+ <mxCell id="glow" parent="1" vertex="1" value="" style="ellipse;html=0;fillColor=#ff5a5f;strokeColor=none;opacity=12;">+ <mxGeometry x="270" y="284" width="320" height="76" as="geometry" />+ </mxCell>+ <mxCell id="panic" parent="1" vertex="1" value="panic()" style="rounded=1;arcSize=50;html=0;fillColor=#2a1418;strokeColor=#ff5a5f;strokeWidth=1.5;fontFamily=Helvetica;fontSize=18;fontStyle=1;fontColor=#ff9a9d;">+ <mxGeometry x="360" y="300" width="140" height="44" as="geometry" />+ </mxCell>++ <mxCell id="unwind" parent="1" edge="1" value="" style="edgeStyle=none;html=0;endArrow=none;strokeColor=#ff5a5f;strokeWidth=2;dashed=1;dashPattern=6 5;">+ <mxGeometry relative="1" as="geometry">+ <mxPoint x="500" y="322" as="sourcePoint" />+ <mxPoint x="800" y="322" as="targetPoint" />+ </mxGeometry>+ </mxCell>+ <mxCell id="m1" parent="1" vertex="1" value="" style="ellipse;html=0;fillColor=#0a0d14;strokeColor=#22e0a8;strokeWidth=1.5;">+ <mxGeometry x="609" y="315" width="14" height="14" as="geometry" />+ </mxCell>+ <mxCell id="m2" parent="1" vertex="1" value="" style="ellipse;html=0;fillColor=#0a0d14;strokeColor=#22e0a8;strokeWidth=1.5;">+ <mxGeometry x="655" y="315" width="14" height="14" as="geometry" />+ </mxCell>+ <mxCell id="m3" parent="1" vertex="1" value="" style="ellipse;html=0;fillColor=#0a0d14;strokeColor=#22e0a8;strokeWidth=1.5;">+ <mxGeometry x="701" y="315" width="14" height="14" as="geometry" />+ </mxCell>+ <mxCell id="m4" parent="1" vertex="1" value="" style="ellipse;html=0;fillColor=#0a0d14;strokeColor=#22e0a8;strokeWidth=1.5;">+ <mxGeometry x="747" y="315" width="14" height="14" as="geometry" />+ </mxCell>++ <mxCell id="exit" parent="1" edge="1" value="exit(1)" style="edgeStyle=none;html=0;endArrow=block;endFill=1;strokeColor=#ff5a5f;strokeWidth=2;fontFamily=Helvetica;fontSize=14;fontColor=#ff8a8d;labelBackgroundColor=none;">+ <mxGeometry relative="1" as="geometry" x="0" y="12">+ <mxPoint x="800" y="322" as="sourcePoint" />+ <mxPoint x="940" y="322" as="targetPoint" />+ </mxGeometry>+ </mxCell>+ <mxCell id="restart" parent="1" edge="1" value="clean process" style="edgeStyle=none;html=0;endArrow=block;endFill=1;strokeColor=#22e0a8;strokeWidth=2;fontFamily=Helvetica;fontSize=14;fontColor=#7ff0c8;labelBackgroundColor=none;">+ <mxGeometry relative="1" as="geometry" x="0" y="12">+ <mxPoint x="940" y="362" as="sourcePoint" />+ <mxPoint x="800" y="362" as="targetPoint" />+ </mxGeometry>+ </mxCell>++ <mxCell id="supervisor" parent="1" vertex="1" value="" style="rounded=1;arcSize=8;html=0;fillColor=#0c1714;strokeColor=#22e0a8;strokeWidth=1.5;">+ <mxGeometry x="940" y="278" width="210" height="128" as="geometry" />+ </mxCell>+ <mxCell id="supervisor-t" parent="1" vertex="1" value="supervisor" style="text;html=0;align=center;verticalAlign=middle;fontFamily=Helvetica;fontSize=18;fontStyle=1;fontColor=#f4f6fb;strokeColor=none;fillColor=none;">+ <mxGeometry x="940" y="308" width="210" height="28" as="geometry" />+ </mxCell>+ <mxCell id="supervisor-s" parent="1" vertex="1" value="systemd · Docker · kubelet" style="text;html=0;align=center;verticalAlign=middle;fontFamily=Helvetica;fontSize=13;fontColor=#7ff0c8;strokeColor=none;fillColor=none;">+ <mxGeometry x="940" y="338" width="210" height="24" as="geometry" />+ </mxCell>+ </root>+ </mxGraphModel>+ </diagram>+</mxfile>diff --git a/diagrams/blog/reliable-apps-crash-so-why-does-go-recover-panics/restaurant-vs-go-service.mjs b/diagrams/blog/reliable-apps-crash-so-why-does-go-recover-panics/restaurant-vs-go-service.mjsnew file mode 100644index 00000000..e165eada--- /dev/null+++ b/diagrams/blog/reliable-apps-crash-so-why-does-go-recover-panics/restaurant-vs-go-service.mjs@@ -0,0 +1,183 @@+// Two-panel comparison of the restaurant analogy and the Go service, used as the+// hero image and the OG card. Dark palette from website/app/globals.css, titles+// in JetBrains Mono and body in Inter like the site itself. Render:+// npm i playwright && node restaurant-vs-go-service.mjs+// Both fonts are embedded as subsetted woff2 (Inter is the variable font, so one+// file covers every weight), so the SVG renders the same everywhere without+// fetching anything. Output goes to+// website/public/blog/reliable-apps-crash-so-why-does-go-recover-panics/.+import { chromium } from "playwright";+import fs from "node:fs";+import path from "node:path";+import { fileURLToPath } from "node:url";++const HERE = path.dirname(fileURLToPath(import.meta.url));+const OUT_DIR = path.resolve(HERE, "../../../website/public/blog/reliable-apps-crash-so-why-does-go-recover-panics");+const SVG_NAME = process.argv[2] ?? "restaurant-vs-go-service.svg";+const PNG_NAME = process.argv[3] ?? "og.png";++const inter = fs.readFileSync(path.join(HERE, "fonts/inter.sub.woff2")).toString("base64");+const mono = fs.readFileSync(path.join(HERE, "fonts/jetbrains-mono-700.sub.woff2")).toString("base64");++const spec = {+ width: 1200,+ height: 630,+ bg: "#0a0d14",+ eyebrow: "RELIABLE APPS CRASH. THE GOOD ONES COME BACK CLEAN.",+ panel: { fill: "#10151f", stroke: "#283041" },+ divider: "#283041",+ arrow: "#5a6374",+ fg0: "#f4f6fb",+ fg1: "#c9d0dd",+ fg2: "#8a93a6",+ fg3: "#5a6374",+ panels: [+ {+ x: 44, y: 60, w: 548, h: 452, rx: 18,+ pill: { fill: "#241b16", stroke: "#5a3d2a", text: "#ffcfa8" },+ title: "Restaurant",+ subtitle: "The fridge broke and stayed warm all night.",+ steps: [+ { color: "red", lines: ["Close the doors, throw out", "everything you can't trust"] },+ { color: "blue", lines: ["Restock from a supplier you trust"] },+ { color: "green", lines: ["Seat guests again"] },+ ],+ },+ {+ x: 608, y: 60, w: 548, h: 452, rx: 18,+ pill: { fill: "#141d30", stroke: "#2c4a7a", text: "#aecbff" },+ title: "Go service",+ subtitle: "A panic landed between two writes.",+ steps: [+ { color: "red", lines: ["exit(1), nothing in memory survives"] },+ { color: "blue", lines: ["The supervisor starts a clean process", "that rebuilds from durable state"] },+ { color: "green", lines: ["Readiness passes, traffic comes back"] },+ ],+ },+ ],+ colors: {+ red: { fill: "#1b1115", stroke: "#ff5a5f", text: "#ffb1b3" },+ blue: { fill: "#0d1a26", stroke: "#00d4ff", text: "#9fe6ff" },+ green: { fill: "#0c1714", stroke: "#22e0a8", text: "#7ff0c8" },+ },+ legend: [+ { color: "red", label: "Stop and discard what you can't trust" },+ { color: "blue", label: "Rebuild from a source you trust" },+ { color: "green", label: "Serve again, invariants hold" },+ ],+};++const SANS = "Inter, -apple-system, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif";+const MONO = "'JetBrains Mono', ui-monospace, SFMono-Regular, Menlo, Consolas, monospace";+const fontFaces =+ `@font-face{font-family:'Inter';font-weight:100 900;font-style:normal;src:url(data:font/woff2;base64,${inter}) format('woff2')}` ++ `@font-face{font-family:'JetBrains Mono';font-weight:700;font-style:normal;src:url(data:font/woff2;base64,${mono}) format('woff2')}`;++const browser = await chromium.launch();+const page = await browser.newPage({ viewport: { width: spec.width, height: spec.height }, deviceScaleFactor: 1 });+await page.setContent(`<!doctype html><html><head><style>${fontFaces}html,body{margin:0;background:${spec.bg}}</style></head><body></body></html>`);+await page.evaluate(() => document.fonts.ready);++const svgMarkup = await page.evaluate(async ({ spec, fontFaces, SANS, MONO }) => {+ const NS = "http://www.w3.org/2000/svg";+ const svg = document.createElementNS(NS, "svg");+ svg.setAttribute("xmlns", NS);+ svg.setAttribute("viewBox", `0 0 ${spec.width} ${spec.height}`);+ svg.setAttribute("width", spec.width);+ svg.setAttribute("height", spec.height);+ svg.setAttribute("role", "img");+ svg.setAttribute("font-family", SANS);+ document.body.appendChild(svg);++ const el = (name, attrs, parent = svg) => {+ const e = document.createElementNS(NS, name);+ for (const [k, v] of Object.entries(attrs)) e.setAttribute(k, v);+ parent.appendChild(e);+ return e;+ };+ const text = (x, y, str, { size = 22, weight = 500, fill = spec.fg1, anchor = "middle", family, spacing } = {}, parent = svg) => {+ const attrs = { x, y, "font-size": size, "font-weight": weight, fill, "text-anchor": anchor };+ if (family) attrs["font-family"] = family;+ if (spacing) attrs["letter-spacing"] = spacing;+ const t = el("text", attrs, parent);+ t.textContent = str;+ return t;+ };+ const width = (t) => t.getComputedTextLength();++ const defs = el("defs", {});+ const style = document.createElementNS(NS, "style");+ style.textContent = fontFaces;+ defs.appendChild(style);+ const marker = el("marker", { id: "arrow", viewBox: "0 0 10 10", refX: 8, refY: 5, markerWidth: 7, markerHeight: 7, orient: "auto-start-reverse" }, defs);+ el("path", { d: "M 0 0 L 10 5 L 0 10 z", fill: spec.arrow }, marker);++ el("rect", { x: 0, y: 0, width: spec.width, height: spec.height, fill: spec.bg });+ text(44, 40, spec.eyebrow, { size: 12, weight: 700, fill: spec.fg3, anchor: "start", family: MONO, spacing: 1.6 });++ const dividerX = (spec.panels[0].x + spec.panels[0].w + spec.panels[1].x) / 2;+ el("line", { x1: dividerX, y1: spec.panels[0].y + 24, x2: dividerX, y2: spec.panels[0].y + spec.panels[0].h - 24, stroke: spec.divider, "stroke-width": 1.5 });++ for (const p of spec.panels) {+ const g = el("g", {});+ el("rect", { x: p.x, y: p.y, width: p.w, height: p.h, rx: p.rx, fill: spec.panel.fill, stroke: spec.panel.stroke, "stroke-width": 1.5 }, g);+ const cx = p.x + p.w / 2;++ // title pill sized to the text+ const title = text(cx, p.y + 57, p.title, { size: 28, weight: 700, fill: p.pill.text, family: MONO }, g);+ const tw = width(title);+ const pill = el("rect", { x: cx - tw / 2 - 28, y: p.y + 20, width: tw + 56, height: 54, rx: 27, fill: p.pill.fill, stroke: p.pill.stroke, "stroke-width": 1.5 }, g);+ g.insertBefore(pill, title);++ text(cx, p.y + 114, p.subtitle, { size: 21, fill: spec.fg2 }, g);++ const boxW = 484, boxH = 76, gap = 32;+ const bx = cx - boxW / 2;+ let by = p.y + 138;+ p.steps.forEach((s, i) => {+ const c = spec.colors[s.color];+ el("rect", { x: bx, y: by, width: boxW, height: boxH, rx: 12, fill: c.fill, stroke: c.stroke, "stroke-width": 1.5 }, g);+ const lh = 27;+ const startY = by + boxH / 2 - ((s.lines.length - 1) * lh) / 2 + 8;+ s.lines.forEach((line, li) => text(cx, startY + li * lh, line, { size: 22, fill: c.text }, g));+ if (i < p.steps.length - 1) {+ el("line", { x1: cx, y1: by + boxH + 4, x2: cx, y2: by + boxH + gap - 6, stroke: spec.arrow, "stroke-width": 1.6, "marker-end": "url(#arrow)" }, g);+ }+ by += boxH + gap;+ });+ }++ // legend: measure labels, then lay out centered+ const legendY = 572;+ const sw = 20, swGap = 12, itemGap = 48;+ const items = spec.legend.map((l) => {+ const t = text(0, legendY + 7, l.label, { size: 19, fill: spec.fg1, anchor: "start" });+ return { ...l, t, w: sw + swGap + width(t) };+ });+ const total = items.reduce((a, it) => a + it.w, 0) + itemGap * (items.length - 1);+ let x = spec.width / 2 - total / 2;+ for (const it of items) {+ const c = spec.colors[it.color];+ el("rect", { x, y: legendY - sw / 2, width: sw, height: sw, rx: 5, fill: c.fill, stroke: c.stroke, "stroke-width": 1.5 });+ it.t.setAttribute("x", x + sw + swGap);+ x += it.w + itemGap;+ }++ return svg.outerHTML;+}, { spec, fontFaces, SANS, MONO });++fs.mkdirSync(OUT_DIR, { recursive: true });+const svgPath = path.join(OUT_DIR, SVG_NAME);+fs.writeFileSync(svgPath, svgMarkup);+console.log("wrote", svgPath, (svgMarkup.length / 1024).toFixed(1), "KB");++// rasterize the finished SVG through an <img>, exactly as the blog loads it+const svgDataUrl = "data:image/svg+xml;base64," + Buffer.from(svgMarkup).toString("base64");+const og = await browser.newPage({ viewport: { width: spec.width, height: spec.height }, deviceScaleFactor: 1 });+await og.setContent(`<html><body style="margin:0;background:${spec.bg}"><img id="i" src="${svgDataUrl}" width="${spec.width}" height="${spec.height}" style="display:block"></body></html>`);+await og.waitForFunction(() => document.getElementById("i").complete);+await og.waitForTimeout(300);+const pngPath = path.join(OUT_DIR, PNG_NAME);+await og.screenshot({ path: pngPath, clip: { x: 0, y: 0, width: spec.width, height: spec.height } });+console.log("wrote", pngPath);+await browser.close();diff --git a/website/app/blog/[slug]/page.tsx b/website/app/blog/[slug]/page.tsxindex 6042a364..49818a11 100644--- a/website/app/blog/[slug]/page.tsx+++ b/website/app/blog/[slug]/page.tsx@@ -2,6 +2,7 @@ import { notFound } from "next/navigation";import type { Metadata } from "next";import { BlogArticle } from "@/components/blog-article";import { getPostsByCategory, getPostBySlug, postMetadata } from "@/lib/blog";+import { vscodeDarkShiki } from "@/lib/shiki-theme-vscode";type Params = { slug: string };@@ -36,6 +37,7 @@ export default async function BlogPostPage({backHref="/blog"eyebrow="Engineering"showSubscribe+ codeTheme={vscodeDarkShiki}/>);}diff --git a/website/app/globals.css b/website/app/globals.cssindex 655ed62f..91a8dc96 100644--- a/website/app/globals.css+++ b/website/app/globals.css@@ -1128,6 +1128,12 @@.blog-body li {margin: 8px 0;}+ .blog-body ol {+ list-style: decimal;+ }+ .blog-body ul {+ list-style: disc;+ }.blog-body strong {color: var(--fg-0);font-weight: 600;diff --git a/website/components/blog-article.tsx b/website/components/blog-article.tsxindex 263664df..d47ed9e2 100644--- a/website/components/blog-article.tsx+++ b/website/components/blog-article.tsx@@ -11,23 +11,25 @@ import { BlogSubscribe } from "@/components/blog-subscribe";import type { BlogPost } from "@/lib/blog";import { tracewayShiki } from "@/lib/shiki-theme";-const prettyCodeOptions: RehypePrettyCodeOptions = {- theme: tracewayShiki,- keepBackground: false,- defaultLang: "plaintext",-};-export function BlogArticle({post,backHref,eyebrow,showSubscribe,+ codeTheme = tracewayShiki,}: {post: BlogPost;backHref: string;eyebrow: string;showSubscribe: boolean;+ codeTheme?: RehypePrettyCodeOptions["theme"];}) {+ const prettyCodeOptions: RehypePrettyCodeOptions = {+ theme: codeTheme,+ keepBackground: false,+ defaultLang: "plaintext",+ };+return (<main className="relative blog-scope"><section className="wrap pt-6 pb-24">diff --git a/website/content/blog/auto-fix-loop.mdx b/website/content/blog/auto-fix-loop.mdxindex 623cb60c..359d8365 100644--- a/website/content/blog/auto-fix-loop.mdx+++ b/website/content/blog/auto-fix-loop.mdx@@ -25,19 +25,11 @@ In this tutorial the trigger will be opening a GitHub issue with the 'traceway'In the dashboard, go to **Alerts → Channels** and add a **GitHub** channel. It takes a fine-grained GitHub personal access token with issue write permission on your repo, the owner and repo name, and a list of labels. Put `traceway` in the labels field. This matters more than it seems: the channel applies exactly the labels you configure, nothing is automatic, and that label is the tripwire the workflow listens for. If the labels field is empty, issues still get created and the workflow never fires, silently. Don't reuse a label humans also apply by hand.-<img- src="/blog/auto-fix-loop/img1-github-channel.webp"- alt="New Channel dialog configured with the GitHub type, a personal access token, the repository owner and name, and the traceway label"- width="320px"-/>+<img width="320" alt="New Channel dialog configured with the GitHub type, a personal access token, the repository owner and name, and the traceway label" src="/blog/auto-fix-loop/img1-github-channel.webp" />Then add a rule: type **New Issue**, attached to that channel. This is what actually gets Traceway to notify your channel when a New Issue shows up.-<img- src="/blog/auto-fix-loop/img2-github-rule.webp"- alt="New Rule dialog with the New Issue rule type attached to the GitHub channel, ignore patterns, a 15 minute cooldown, and critical severity"- width="320px"-/>+<img width="320" alt="New Rule dialog with the New Issue rule type attached to the GitHub channel, ignore patterns, a 15 minute cooldown, and critical severity" src="/blog/auto-fix-loop/img2-github-rule.webp" />With this setup, every new exception will automatically create a GitHub issue on our behalf.@@ -98,6 +90,7 @@ That's a real one from our production, and those three lines in the middle matteWe don't have to worry about those things with Traceway as it already provides this info by default and the Traceway skill we will let the agent use knows how to parse all of them out of a notification body.To let the agent access this data Traceway exposes two paths:+- CLI + Skill- MCP@@ -144,7 +137,6 @@ This step is awesome, it triggers Claude Code with the Opus 4.8 model and the efAlso note the max-turns 60 cap: if the agent hasn't finished by then the run is cut off, so a stuck loop can't burn tokens indefinitely.-## The Prompt (do not make mistakes)The prompt is honestly pretty basic, it tells the LLM what to do. The LLM will use your repo's `CLAUDE.md` file but as I've come to learn the hard way it can ignore it. The `CLAUDE.md` file is more like a suggestion, the prompt is much more likely to be followed. Here is what our prompt looks like:@@ -282,13 +274,13 @@ I found this to be really interesting, two runs of the exact same problem but coThe full workflow is [located here](https://github.com/tracewayapp/traceway/blob/main/.github/workflows/traceway-autofix.yml). The issue used for testing is [here](https://github.com/tracewayapp/traceway/issues/278) and the PR one of the runs opened is [here](https://github.com/tracewayapp/traceway/pull/279). To set up the same workflow you will need these configured in your repository settings:-| Name | Kind | What it is | Where to get it |-| --- | --- | --- | --- |-| `ANTHROPIC_API_KEY` | Secret | The API key Claude Code uses, this is the one that costs money so set a spend limit on it | [Anthropic Console](https://console.anthropic.com) under API keys |-| `TRACEWAY_TOKEN` | Secret | A personal access token (`twp_...`) the CLI uses to read your telemetry, shown only once so copy it right away | Traceway dashboard, **Account → Personal access tokens** |-| `TRACEWAY_PROJECT_ID` | Variable | The ID of the project your app reports into, it's just an address so it doesn't need to be a secret | The `projectId` query param in your Traceway dashboard URL |+| Name | Kind | What it is | Where to get it |+| --------------------- | -------- | -------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------- |+| `ANTHROPIC_API_KEY` | Secret | The API key Claude Code uses, this is the one that costs money so set a spend limit on it | [Anthropic Console](https://console.anthropic.com) under API keys |+| `TRACEWAY_TOKEN` | Secret | A personal access token (`twp_...`) the CLI uses to read your telemetry, shown only once so copy it right away | Traceway dashboard, **Account → Personal access tokens** |+| `TRACEWAY_PROJECT_ID` | Variable | The ID of the project your app reports into, it's just an address so it doesn't need to be a secret | The `projectId` query param in your Traceway dashboard URL |----+***## Reflection@@ -298,8 +290,8 @@ While building it I had to start thinking about whole new sets of issues, primarAnother thing that I did not expect was that the agent made two completely different decisions in two separate runs and decided to ignore the CLAUDE.md instructions on how to write code leading to pretty mediocre results. Focusing on driving outcomes will be next, evaluating the changes done to the prompt/tooling/steps/skills will probably play a much larger role than the changes themselves. Having a non deterministic system and trying to improve upon it will obviously require a lot of measurements.-The final thing that this little experiment left me thinking about is the observability piece of the agent itself. I spent a total of ~$10 across 3-4 runs of the agent, it was easy to track and to check what the agent was doing. Running this at scale would be a completely different beast. The GenAI spec in OTel is done and having great support for it in Traceway is on my roadmap, building a better agent will help me make sure it's implemented well.+The final thing that this little experiment left me thinking about is the observability piece of the agent itself. I spent a total of \~$10 across 3-4 runs of the agent, it was easy to track and to check what the agent was doing. Running this at scale would be a completely different beast. The GenAI spec in OTel is done and having great support for it in Traceway is on my roadmap, building a better agent will help me make sure it's implemented well.----+***-_I'm building this in the open. Traceway is MIT-licensed and OpenTelemetry-native, and everything described here ships with it. If you wire this loop up and an agent fixes a real bug while you were asleep, I genuinely want to hear about it: [email protected]._+_I'm building this in the open. Traceway is MIT-licensed and OpenTelemetry-native, and everything described here ships with it. If you wire this loop up and an agent fixes a real bug while you were asleep, I genuinely want to hear about it:_ [[email protected]_](mailto:[email protected])_._\ No newline at end of filediff --git a/website/content/blog/reliable-apps-crash-so-why-does-go-recover-panics.mdx b/website/content/blog/reliable-apps-crash-so-why-does-go-recover-panics.mdxnew file mode 100644index 00000000..8fdca00f--- /dev/null+++ b/website/content/blog/reliable-apps-crash-so-why-does-go-recover-panics.mdx@@ -0,0 +1,241 @@+---+title: 'Reliable Apps Crash: So Why Does net/http Recover Panics?'+date: '2026-08-29'+category: engineering+author: dusan+image: /blog/reliable-apps-crash-so-why-does-go-recover-panics/og.png+description: >-+ What separates good restaurants from bad ones is consistency. When you order+ the same meal twice, you expect the same meal twice. That predictability is+ what makes them reliable. A distributed system needs the same property.+---++If your service is built on `net/http`, it already recovers panics in handlers. The server catches the panic, logs a stack trace, closes the connection, and moves on to the next request. Nothing in your code asked for that. It is the default, and it is why "the process is still up" feels like the same thing as "the service is fine", but it is not. Reliable is not the same as running.++++To build truly reliable systems, we must make them predictable. For a system to be predictable, it has to have a set of rules that must hold true when it is observed. These rules are called _invariants_. An account balance must be positive. An index and the data must agree. If a cache reports that it contains 10 entries, then its map has to have 10 keys.++Invariants can be broken briefly while the system cannot be observed. This is done to update related pieces of state. To outside observers, these operations appear atomic. The invariants we're breaking must be restored before we give control back to the caller or release the lock.++This distinction matters less when you're building a CRUD app on a single database, because someone already built the boundary for you. The transaction owns every write you make inside it, and a panic in the middle means it never commits. When you are the one building the stateful thing, a database, a queue, a scheduler, or any service with shared in-memory state, you have to establish and enforce these invariants yourself.++## Reliability is a state++After a panic occurs, the goal is not to keep the process alive; it's to return the service to a valid internal state and make sure its invariants hold again.++A _side effect_ is anything a function does besides compute its return value: writing to a map, taking a lock, appending to a slice someone else holds, inserting a database row, writing a file, and so on. A function with no side effects can be called, fail, and be called again with nothing to clean up. A function with side effects has made changes that will stay after the function is gone, whether it returned normally or not.++Go's `recover()` only works when called directly by a deferred function on the same goroutine that is panicking. When it succeeds, it stops the panic from continuing up the stack. It does not resume execution at the line that panicked, undo writes, repair shared state, or restart a goroutine. The functions between the panic and the recovery point are gone, and the function that installed the defer returns to its caller. Their deferred calls still run on the way out, which is why the mutex in the example below gets unlocked. This is important because it gives us a simple rule: handle panics only at the _boundary_ where every possible side effect can be rolled back, discarded and rebuilt, or reconciled. That boundary might be an operation, a request, a durable job attempt, a worker, or the entire process. If we cannot identify a safe boundary inside the process, we should terminate it and let an external supervisor start a clean one.++Yes, you read that right: if you cannot safely roll back all of the side effects, you should not blindly recover, but instead let the app **crash** and have the supervisor restart it.++### The problem: key-value store++To demonstrate, we will build a simple cache service in Go. We will start with a naive version, show why it is unsafe, then fix it twice: once by removing the duplicated fact, and once by making the process the recovery boundary. We'll use a map to store the key-value pairs. The map access will be guarded by a mutex, and we'll define simple set and stats functions.++> The cache has one invariant: `numKeys` must always equal `len(values)` when no operation is in progress.++The `PANIC` value below is a deliberate failure injection. In real code, it could be a nil pointer dereference, a failed type assertion, or a library panic. What matters is that it happens after the first mutation and before the second.++```go+package main++import (+ "fmt"+ "io"+ "log"+ "net/http"+ "sync"+)++type Cache struct {+ mu sync.RWMutex+ values map[string]string+ numKeys int+}++func (c *Cache) Set(key, value string) {+ c.mu.Lock()+ defer c.mu.Unlock()++ if _, exists := c.values[key]; !exists {+ c.numKeys+++ }+ if value == "PANIC" {+ panic("simulated failure")+ }+ c.values[key] = value+}++func (c *Cache) Stats() (numKeys, storedKeys int) {+ c.mu.RLock()+ defer c.mu.RUnlock()+ return c.numKeys, len(c.values)+}++func main() {+ cache := &Cache{values: make(map[string]string)}+ mux := http.NewServeMux()++ mux.HandleFunc("PUT /cache/{key}", func(w http.ResponseWriter, r *http.Request) {+ body, err := io.ReadAll(http.MaxBytesReader(w, r.Body, 1024))+ if err != nil {+ http.Error(w, "invalid value", http.StatusBadRequest)+ return+ }++ cache.Set(r.PathValue("key"), string(body))+ w.WriteHeader(http.StatusNoContent)+ })++ mux.HandleFunc("GET /stats", func(w http.ResponseWriter, _ *http.Request) {+ numKeys, storedKeys := cache.Stats()+ fmt.Fprintf(w, "reported_keys=%d stored_keys=%d\n", numKeys, storedKeys)+ })++ log.Fatal(http.ListenAndServe(":8080", mux))+}+```++Start the server and make these requests:++```bash+curl -X PUT http://localhost:8080/cache/first -d 'hello'+curl -X PUT http://localhost:8080/cache/second -d 'PANIC'+curl http://localhost:8080/stats+```++The second request fails with `curl: (52) Empty reply from server` because `net/http` closes the connection, and the server logs `http: panic serving [::1]:55242: simulated failure` followed by a stack trace. The process stays alive, so the final request still succeeds:++```+reported_keys=2 stored_keys=1+```++Is the process alive? Yes.++Is the cache reliable? No.++Does that make `net/http` wrong? Also no.++The mutex did its job. The cache is up and available, but the problem is that it disagrees with itself. The panic happened in an unexpected place, and the default boundary was not correct for our application. The `net/http` design works for most apps, but it does not work for all apps.++The [`net/http` contract](https://pkg.go.dev/net/http#Handler) says the server **assumes** that the effect of a handler panic is isolated to the active request. In our case, that was not correct. This doesn't mean that we cannot build complex systems with internal state in Go. It means we must be aware of its interfaces and contracts in order to maintain our invariants. Our two independent in-memory mutations are not isolated. `recover()` is a language feature, but recovery is a system property.++Once the cache disagrees with itself, we have at least three choices:++1. Roll back the partial mutation if we know exactly what changed.+2. Reset the entire cache if all of its state is reconstructible.+3. Terminate the process if neither in-process repair can be proven safe.++You're thinking: just don't store the count twice. Correct. That is the fix in this case. Now do it for an LRU cache, where a map and a linked list must agree. Or a B-tree with a dirty page list. Or a connection pool that counts what it has handed out. Systems store the same fact twice on purpose, because the second copy is what makes them fast, and a panic does not care which of the two writes it lands between. Here the fix is one deleted field. In most other cases, this is not trivial. The one option that is always easy, however, is terminating the process. It shouldn't be our only strategy, but it should be our last line of defense. It is always available, even for panics in our recovery logic.++### The narrow fix++The narrow fix is to stop storing the same fact twice:++```go+type Cache struct {+ mu sync.RWMutex+ values map[string]string+}++func (c *Cache) Set(key, value string) {+ c.mu.Lock()+ defer c.mu.Unlock()++ if value == "PANIC" {+ panic("simulated failure")+ }+ c.values[key] = value+}++func (c *Cache) Len() int {+ c.mu.RLock()+ defer c.mu.RUnlock()+ return len(c.values)+}+```++With `Stats` gone, the `/stats` handler prints `cache.Len()` instead. Now the map is the only source of truth. The panic still interrupts the request, but there is no second value that can disagree with it.++## When the process is the recovery boundary++Let's talk about the restaurant again. When the fridge breaks and has been warm all night, the kitchen does not keep serving just because the doors are open. It closes, throws out everything it cannot trust, restocks, and only then seats guests again.++The process becomes the recovery boundary when we cannot prove that anything smaller owns everything the panicked code might have changed. Recovery code is still code, so it can fail too. It might depend on a database that is unavailable, inherit corrupted state, or panic while trying to clean up.++In that situation, continuing to serve traffic turns uncertainty into an API contract. A clean process is safer because its memory, locks, stacks, and goroutines are rebuilt from scratch. This works only when important state is durable or reconstructible. Restarting cannot repair corrupted durable data, recall an email, or uncharge a card.++There is one Go-specific complication. Letting a panic escape `ServeHTTP` does not terminate the process because `net/http` catches that panic at its own boundary. If a service decides that a handler has compromised process-wide state, it needs an explicit fatal path owned by the application, one that stops serving and exits with a nonzero status. A panic caught by `net/http` is not such a path.++### The process fix++For the original cache, the broader alternative is to catch a panic around the state-changing operation and exit before `net/http` can recover it. With `os` and `runtime/debug` imported, replace the call to `cache.Set` with `setOrExit`:++```go+func setOrExit(cache *Cache, key, value string) {+ defer func() {+ if failure := recover(); failure != nil {+ log.Printf("fatal cache panic: %v\n%s", failure, debug.Stack())+ os.Exit(1)+ }+ }()++ cache.Set(key, value)+}+```++The second `PUT` now terminates the process with status 1. Its supervisor can start a new process whose empty cache satisfies the invariant again.++This is why "always recover" and "always crash" are both bad strategies. If one malformed request can restart every instance, a small bug can become a denial-of-service attack. Request-level recovery is the right default when the request is truly isolated. Process termination is the safer choice when shared state is invalid or we cannot determine whether it is still valid.++To turn a crash into a restart instead of an outage, we need a supervisor.++## The supervisor++A supervisor sits outside the unit that can fail. Its job is to notice that the unit stopped and create a replacement from a state known to be good. For a worker, that supervisor may be another goroutine. Go does not send a panic from one goroutine to another, so the worker must catch its own panic and report that it stopped. Without that wrapper, an unrecovered worker panic terminates the whole process before another goroutine can restart it.++The wrapper is short. The goroutine recovers its own panic, records it with the stack, and tells the supervisor goroutine to start a replacement:++```go+go func() {+ defer func() {+ if failure := recover(); failure != nil {+ log.Printf("worker panic: %v\n%s", failure, debug.Stack())+ restart <- struct{}{}+ }+ }()+ worker()+}()+```++For a process, the supervisor is usually systemd, Docker, a kubelet, or another process manager.++I have shipped an app whose background goroutines had no such wrapper, behind a supervisor that was misconfigured and slow to restart. One goroutine panic took production down. Learn from my mistake. Recover in long-running goroutines when the worker owns its state, configure the supervisor properly, and make the app restart fast.++The supervisor is part of the recovery design, not a magic property of deployment. It must be configured to restart failed units and back off when the same deterministic bug keeps crashing them. A restart is only half of the job. Something in the deployment also has to keep the replacement out of traffic until it is ready. Depending on the setup, that might be the supervisor, an orchestrator, or a load balancer. Without readiness and backoff, restarts can amplify load and turn one failure into a crash loop across the fleet.++Common configurations include:++- A systemd unit with `Restart=on-failure` and `RestartSec=5s`, which restarts a failed process after a short delay.+- A Docker container with an `on-failure` restart policy, which restarts the container when its process exits unsuccessfully.+- A Kubernetes Pod with a readiness probe, which stays out of Service traffic until it is ready, while the kubelet restarts failed containers with backoff.++## Building your boundaries++You already use the best recovery boundary ever built: a database transaction. Every write inside it can be rolled back, which is why CRUD apps get to be relaxed about panics. It stops working the moment one side effect leaves the database. Insert the order, then send the email. Panic between them and the order exists but the email is gone, and no rollback can fix that. The outbox pattern solves it: instead of sending the email, save it as a row in the same transaction as the order, and let a worker send it later. Now a crash loses nothing. The row survives, the worker retries. Everything that matters is durable, so the process itself is allowed to crash.++These are common recovery boundaries, ordered from narrow to broad. Recover at the narrowest one that owns every side effect, and widen when it does not. Real systems almost never nest them exactly like this:++++However hard you try to recover at a narrow boundary, it will not always be possible, so keep a strong fallback in place. Do not recover a panic just to report it unless you can show that no side effect survives that boundary. Smaller is useful only when it is actually safe.++## Conclusion++We started with a cache that reported two keys and stored one. `net/http` did exactly what its contract says: it assumed the panic was isolated to the request and kept serving, so the process stayed up while the cache disagreed with itself. We fixed that twice, once by deleting the second copy of the fact, and once by exiting before `net/http` could recover and letting the supervisor start a process that agrees with itself. Neither fix was about keeping the process alive. Both were about getting back to a state where the invariants hold.++Every rule in this post I learned by breaking it. I recovered panics I should have let through. I let one through behind a misconfigured supervisor and took production down. What finally stuck fits in three lines. Recover at the narrowest boundary that owns every side effect. If there is no such boundary, record the panic, flush, and exit 1. Then go read the panic, because the crash was the easy part.++I have also lost stack traces to a process that exited before anyone wrote them down. Don't make that mistake either. Use [Traceway](https://tracewayapp.com "Traceway"). It is where I go to read them. Reliable apps crash. The good ones leave a note too. If you have any questions send me an email at [[email protected]](mailto:[email protected]).diff --git a/website/lib/shiki-theme-vscode.ts b/website/lib/shiki-theme-vscode.tsnew file mode 100644index 00000000..d9d7b6b5--- /dev/null+++ b/website/lib/shiki-theme-vscode.ts@@ -0,0 +1,586 @@+import type { RawThemeSetting, ThemeRegistrationRaw } from "shiki";++// VS Code's Dark+ token colors, copied from shiki's bundled dark-plus theme. The last rule mirrors+// the Go extension's semantic highlighting, which paints every Go keyword with the control-keyword+// purple; the static grammar alone would leave func/type/struct/map blue.+const tokenColors: RawThemeSetting[] = [+ {+ settings: {+ foreground: "#D4D4D4",+ background: "#00000000"+ }+ },+ {+ scope: [+ "meta.embedded",+ "source.groovy.embedded",+ "string meta.image.inline.markdown",+ "variable.legacy.builtin.python"+ ],+ settings: {+ foreground: "#D4D4D4"+ }+ },+ {+ scope: "emphasis",+ settings: {+ fontStyle: "italic"+ }+ },+ {+ scope: "strong",+ settings: {+ fontStyle: "bold"+ }+ },+ {+ scope: "header",+ settings: {+ foreground: "#000080"+ }+ },+ {+ scope: "comment",+ settings: {+ foreground: "#6A9955"+ }+ },+ {+ scope: "constant.language",+ settings: {+ foreground: "#569cd6"+ }+ },+ {+ scope: [+ "constant.numeric",+ "variable.other.enummember",+ "keyword.operator.plus.exponent",+ "keyword.operator.minus.exponent"+ ],+ settings: {+ foreground: "#b5cea8"+ }+ },+ {+ scope: "constant.regexp",+ settings: {+ foreground: "#646695"+ }+ },+ {+ scope: "entity.name.tag",+ settings: {+ foreground: "#569cd6"+ }+ },+ {+ scope: [+ "entity.name.tag.css",+ "entity.name.tag.less"+ ],+ settings: {+ foreground: "#d7ba7d"+ }+ },+ {+ scope: "entity.other.attribute-name",+ settings: {+ foreground: "#9cdcfe"+ }+ },+ {+ scope: [+ "entity.other.attribute-name.class.css",+ "source.css entity.other.attribute-name.class",+ "entity.other.attribute-name.id.css",+ "entity.other.attribute-name.parent-selector.css",+ "entity.other.attribute-name.parent.less",+ "source.css entity.other.attribute-name.pseudo-class",+ "entity.other.attribute-name.pseudo-element.css",+ "source.css.less entity.other.attribute-name.id",+ "entity.other.attribute-name.scss"+ ],+ settings: {+ foreground: "#d7ba7d"+ }+ },+ {+ scope: "invalid",+ settings: {+ foreground: "#f44747"+ }+ },+ {+ scope: "markup.underline",+ settings: {+ fontStyle: "underline"+ }+ },+ {+ scope: "markup.bold",+ settings: {+ fontStyle: "bold",+ foreground: "#569cd6"+ }+ },+ {+ scope: "markup.heading",+ settings: {+ fontStyle: "bold",+ foreground: "#569cd6"+ }+ },+ {+ scope: "markup.italic",+ settings: {+ fontStyle: "italic"+ }+ },+ {+ scope: "markup.strikethrough",+ settings: {+ fontStyle: "strikethrough"+ }+ },+ {+ scope: "markup.inserted",+ settings: {+ foreground: "#b5cea8"+ }+ },+ {+ scope: "markup.deleted",+ settings: {+ foreground: "#ce9178"+ }+ },+ {+ scope: "markup.changed",+ settings: {+ foreground: "#569cd6"+ }+ },+ {+ scope: "punctuation.definition.quote.begin.markdown",+ settings: {+ foreground: "#6A9955"+ }+ },+ {+ scope: "punctuation.definition.list.begin.markdown",+ settings: {+ foreground: "#6796e6"+ }+ },+ {+ scope: "markup.inline.raw",+ settings: {+ foreground: "#ce9178"+ }+ },+ {+ scope: "punctuation.definition.tag",+ settings: {+ foreground: "#808080"+ }+ },+ {+ scope: [+ "meta.preprocessor",+ "entity.name.function.preprocessor"+ ],+ settings: {+ foreground: "#569cd6"+ }+ },+ {+ scope: "meta.preprocessor.string",+ settings: {+ foreground: "#ce9178"+ }+ },+ {+ scope: "meta.preprocessor.numeric",+ settings: {+ foreground: "#b5cea8"+ }+ },+ {+ scope: "meta.structure.dictionary.key.python",+ settings: {+ foreground: "#9cdcfe"+ }+ },+ {+ scope: "meta.diff.header",+ settings: {+ foreground: "#569cd6"+ }+ },+ {+ scope: "storage",+ settings: {+ foreground: "#569cd6"+ }+ },+ {+ scope: "storage.type",+ settings: {+ foreground: "#569cd6"+ }+ },+ {+ scope: [+ "storage.modifier",+ "keyword.operator.noexcept"+ ],+ settings: {+ foreground: "#569cd6"+ }+ },+ {+ scope: [+ "string",+ "meta.embedded.assembly"+ ],+ settings: {+ foreground: "#ce9178"+ }+ },+ {+ scope: "string.tag",+ settings: {+ foreground: "#ce9178"+ }+ },+ {+ scope: "string.value",+ settings: {+ foreground: "#ce9178"+ }+ },+ {+ scope: "string.regexp",+ settings: {+ foreground: "#d16969"+ }+ },+ {+ scope: [+ "punctuation.definition.template-expression.begin",+ "punctuation.definition.template-expression.end",+ "punctuation.section.embedded"+ ],+ settings: {+ foreground: "#569cd6"+ }+ },+ {+ scope: [+ "meta.template.expression"+ ],+ settings: {+ foreground: "#d4d4d4"+ }+ },+ {+ scope: [+ "support.type.vendored.property-name",+ "support.type.property-name",+ "source.css variable",+ "source.coffee.embedded"+ ],+ settings: {+ foreground: "#9cdcfe"+ }+ },+ {+ scope: "keyword",+ settings: {+ foreground: "#569cd6"+ }+ },+ {+ scope: "keyword.control",+ settings: {+ foreground: "#569cd6"+ }+ },+ {+ scope: "keyword.operator",+ settings: {+ foreground: "#d4d4d4"+ }+ },+ {+ scope: [+ "keyword.operator.new",+ "keyword.operator.expression",+ "keyword.operator.cast",+ "keyword.operator.sizeof",+ "keyword.operator.alignof",+ "keyword.operator.typeid",+ "keyword.operator.alignas",+ "keyword.operator.instanceof",+ "keyword.operator.logical.python",+ "keyword.operator.wordlike"+ ],+ settings: {+ foreground: "#569cd6"+ }+ },+ {+ scope: "keyword.other.unit",+ settings: {+ foreground: "#b5cea8"+ }+ },+ {+ scope: [+ "punctuation.section.embedded.begin.php",+ "punctuation.section.embedded.end.php"+ ],+ settings: {+ foreground: "#569cd6"+ }+ },+ {+ scope: "support.function.git-rebase",+ settings: {+ foreground: "#9cdcfe"+ }+ },+ {+ scope: "constant.sha.git-rebase",+ settings: {+ foreground: "#b5cea8"+ }+ },+ {+ scope: [+ "storage.modifier.import.java",+ "variable.language.wildcard.java",+ "storage.modifier.package.java"+ ],+ settings: {+ foreground: "#d4d4d4"+ }+ },+ {+ scope: "variable.language",+ settings: {+ foreground: "#569cd6"+ }+ },+ {+ scope: [+ "entity.name.function",+ "support.function",+ "support.constant.handlebars",+ "source.powershell variable.other.member",+ "entity.name.operator.custom-literal"+ ],+ settings: {+ foreground: "#DCDCAA"+ }+ },+ {+ scope: [+ "support.class",+ "support.type",+ "entity.name.type",+ "entity.name.namespace",+ "entity.other.attribute",+ "entity.name.scope-resolution",+ "entity.name.class",+ "storage.type.numeric.go",+ "storage.type.byte.go",+ "storage.type.boolean.go",+ "storage.type.string.go",+ "storage.type.uintptr.go",+ "storage.type.error.go",+ "storage.type.rune.go",+ "storage.type.cs",+ "storage.type.generic.cs",+ "storage.type.modifier.cs",+ "storage.type.variable.cs",+ "storage.type.annotation.java",+ "storage.type.generic.java",+ "storage.type.java",+ "storage.type.object.array.java",+ "storage.type.primitive.array.java",+ "storage.type.primitive.java",+ "storage.type.token.java",+ "storage.type.groovy",+ "storage.type.annotation.groovy",+ "storage.type.parameters.groovy",+ "storage.type.generic.groovy",+ "storage.type.object.array.groovy",+ "storage.type.primitive.array.groovy",+ "storage.type.primitive.groovy"+ ],+ settings: {+ foreground: "#4EC9B0"+ }+ },+ {+ scope: [+ "meta.type.cast.expr",+ "meta.type.new.expr",+ "support.constant.math",+ "support.constant.dom",+ "support.constant.json",+ "entity.other.inherited-class",+ "punctuation.separator.namespace.ruby"+ ],+ settings: {+ foreground: "#4EC9B0"+ }+ },+ {+ scope: [+ "keyword.control",+ "source.cpp keyword.operator.new",+ "keyword.operator.delete",+ "keyword.other.using",+ "keyword.other.directive.using",+ "keyword.other.operator",+ "entity.name.operator"+ ],+ settings: {+ foreground: "#C586C0"+ }+ },+ {+ scope: [+ "variable",+ "meta.definition.variable.name",+ "support.variable",+ "entity.name.variable",+ "constant.other.placeholder"+ ],+ settings: {+ foreground: "#9CDCFE"+ }+ },+ {+ scope: [+ "variable.other.constant",+ "variable.other.enummember"+ ],+ settings: {+ foreground: "#4FC1FF"+ }+ },+ {+ scope: [+ "meta.object-literal.key"+ ],+ settings: {+ foreground: "#9CDCFE"+ }+ },+ {+ scope: [+ "support.constant.property-value",+ "support.constant.font-name",+ "support.constant.media-type",+ "support.constant.media",+ "constant.other.color.rgb-value",+ "constant.other.rgb-value",+ "support.constant.color"+ ],+ settings: {+ foreground: "#CE9178"+ }+ },+ {+ scope: [+ "punctuation.definition.group.regexp",+ "punctuation.definition.group.assertion.regexp",+ "punctuation.definition.character-class.regexp",+ "punctuation.character.set.begin.regexp",+ "punctuation.character.set.end.regexp",+ "keyword.operator.negation.regexp",+ "support.other.parenthesis.regexp"+ ],+ settings: {+ foreground: "#CE9178"+ }+ },+ {+ scope: [+ "constant.character.character-class.regexp",+ "constant.other.character-class.set.regexp",+ "constant.other.character-class.regexp",+ "constant.character.set.regexp"+ ],+ settings: {+ foreground: "#d16969"+ }+ },+ {+ scope: [+ "keyword.operator.or.regexp",+ "keyword.control.anchor.regexp"+ ],+ settings: {+ foreground: "#DCDCAA"+ }+ },+ {+ scope: "keyword.operator.quantifier.regexp",+ settings: {+ foreground: "#d7ba7d"+ }+ },+ {+ scope: [+ "constant.character",+ "constant.other.option"+ ],+ settings: {+ foreground: "#569cd6"+ }+ },+ {+ scope: "constant.character.escape",+ settings: {+ foreground: "#d7ba7d"+ }+ },+ {+ scope: "entity.name.label",+ settings: {+ foreground: "#C8C8C8"+ }+ },+ {+ scope: [+ "keyword.package.go",+ "keyword.function.go",+ "keyword.type.go",+ "keyword.struct.go",+ "keyword.interface.go",+ "keyword.map.go",+ "keyword.channel.go",+ "keyword.var.go",+ "keyword.const.go"+ ],+ settings: {+ foreground: "#C586C0"+ }+ }+];++export const vscodeDarkShiki: ThemeRegistrationRaw = {+ name: "vscode-dark-plus",+ type: "dark",+ colors: {+ "editor.background": "#00000000",+ "editor.foreground": "#D4D4D4",+ },+ settings: tokenColors,+ tokenColors,+};diff --git a/website/public/blog/reliable-apps-crash-so-why-does-go-recover-panics/boundary-ladder.svg b/website/public/blog/reliable-apps-crash-so-why-does-go-recover-panics/boundary-ladder.svgnew file mode 100644index 00000000..9c459d91--- /dev/null+++ b/website/public/blog/reliable-apps-crash-so-why-does-go-recover-panics/boundary-ladder.svg@@ -0,0 +1,136 @@+<?xml version="1.0" encoding="UTF-8" standalone="no"?>+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"+ "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">+<!-- Generated by graphviz version 15.1.1 (20260805.0921)+ -->+<!-- Title: boundary_ladder Pages: 1 -->+<svg width="639pt" height="657pt"+ viewBox="0.00 0.00 639.00 657.00" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">+<g id="graph0" class="graph" transform="scale(1 1) rotate(0) translate(14.4 642.84)">+<title>boundary_ladder</title>+<!-- panic -->+<g id="node1" class="node">+<title>panic</title>+<path fill="#1b1115" stroke="#ff5a5f" stroke-width="1.3" d="M348.45,-628.44C348.45,-628.44 96,-628.44 96,-628.44 90,-628.44 84,-622.44 84,-616.44 84,-616.44 84,-588.52 84,-588.52 84,-582.52 90,-576.52 96,-576.52 96,-576.52 348.45,-576.52 348.45,-576.52 354.45,-576.52 360.45,-582.52 360.45,-588.52 360.45,-588.52 360.45,-616.44 360.45,-616.44 360.45,-622.44 354.45,-628.44 348.45,-628.44"/>+<text xml:space="preserve" text-anchor="start" x="178.73" y="-603.18" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="14.00" fill="#f4f6fb">a panic starts</text>+<text xml:space="preserve" text-anchor="start" x="105.6" y="-591.08" font-family="Helvetica,sans-Serif" font-size="12.00" fill="#ff9a9d">nil pointer · failed type assertion · library bug</text>+</g>+<!-- op -->+<g id="node2" class="node">+<title>op</title>+<path fill="#151a24" stroke="#283041" stroke-width="1.3" d="M377.7,-543.52C377.7,-543.52 66.75,-543.52 66.75,-543.52 60.75,-543.52 54.75,-537.52 54.75,-531.52 54.75,-531.52 54.75,-503.6 54.75,-503.6 54.75,-497.6 60.75,-491.6 66.75,-491.6 66.75,-491.6 377.7,-491.6 377.7,-491.6 383.7,-491.6 389.7,-497.6 389.7,-503.6 389.7,-503.6 389.7,-531.52 389.7,-531.52 389.7,-537.52 383.7,-543.52 377.7,-543.52"/>+<text xml:space="preserve" text-anchor="start" x="191.48" y="-518.26" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="14.00" fill="#f4f6fb">operation</text>+<text xml:space="preserve" text-anchor="start" x="76.35" y="-506.16" font-family="Helvetica,sans-Serif" font-size="12.00" fill="#8a93a6">roll back the partial mutation before the lock is released</text>+</g>+<!-- panic->op -->+<g id="edge1" class="edge">+<title>panic->op</title>+<path fill="none" stroke="#5a6374" stroke-width="1.4" d="M222.23,-576.15C222.23,-569.3 222.23,-561.76 222.23,-554.45"/>+<polygon fill="#5a6374" stroke="#5a6374" stroke-width="1.4" points="225.2,-554.64 222.23,-546.14 219.25,-554.64 225.2,-554.64"/>+</g>+<!-- req -->+<g id="node3" class="node">+<title>req</title>+<path fill="#151a24" stroke="#283041" stroke-width="1.3" d="M388.58,-447.6C388.58,-447.6 55.87,-447.6 55.87,-447.6 49.88,-447.6 43.88,-441.6 43.88,-435.6 43.88,-435.6 43.88,-407.68 43.88,-407.68 43.88,-401.68 49.88,-395.68 55.88,-395.68 55.88,-395.68 388.58,-395.68 388.58,-395.68 394.58,-395.68 400.58,-401.68 400.58,-407.68 400.58,-407.68 400.58,-435.6 400.58,-435.6 400.58,-441.6 394.58,-447.6 388.58,-447.6"/>+<text xml:space="preserve" text-anchor="start" x="197.85" y="-422.34" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="14.00" fill="#f4f6fb">request</text>+<text xml:space="preserve" text-anchor="start" x="65.48" y="-410.24" font-family="Helvetica,sans-Serif" font-size="12.00" fill="#8a93a6">discard everything the request touched (the net/http default)</text>+</g>+<!-- op->req -->+<g id="edge2" class="edge">+<title>op->req</title>+<path fill="none" stroke="#5a6374" stroke-width="1.4" d="M222.23,-491.39C222.23,-481.37 222.23,-469.64 222.23,-458.74"/>+<polygon fill="#5a6374" stroke="#5a6374" stroke-width="1.4" points="225.2,-458.82 222.23,-450.32 219.25,-458.82 225.2,-458.82"/>+<text xml:space="preserve" text-anchor="middle" x="291.98" y="-465.15" font-family="Helvetica,sans-Serif" font-size="11.00" fill="#8a93a6">  side effects survive it: widen</text>+</g>+<!-- ok -->+<g id="node8" class="node">+<title>ok</title>+<path fill="#0c1714" stroke="#22e0a8" stroke-width="1.3" d="M597.83,-351.68C597.83,-351.68 464.62,-351.68 464.62,-351.68 458.62,-351.68 452.62,-345.68 452.62,-339.68 452.62,-339.68 452.62,-299.76 452.62,-299.76 452.62,-293.76 458.62,-287.76 464.62,-287.76 464.62,-287.76 597.83,-287.76 597.83,-287.76 603.83,-287.76 609.83,-293.76 609.83,-299.76 609.83,-299.76 609.83,-339.68 609.83,-339.68 609.83,-345.68 603.83,-351.68 597.83,-351.68"/>+<text xml:space="preserve" text-anchor="start" x="498.98" y="-326.42" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="14.00" fill="#f4f6fb">recovered</text>+<text xml:space="preserve" text-anchor="start" x="474.23" y="-314.32" font-family="Helvetica,sans-Serif" font-size="12.00" fill="#7ff0c8">invariants hold again,</text>+<text xml:space="preserve" text-anchor="start" x="497.1" y="-302.32" font-family="Helvetica,sans-Serif" font-size="12.00" fill="#7ff0c8">keep serving</text>+</g>+<!-- op->ok -->+<g id="edge7" class="edge">+<title>op:e->ok:w</title>+<path fill="none" stroke="#22e0a8" stroke-width="1.4" d="M390.7,-517.56C432.93,-517.56 410.2,-350.85 441.78,-323.5"/>+<polygon fill="#22e0a8" stroke="#22e0a8" stroke-width="1.4" points="442.77,-326.3 449.65,-320.48 440.64,-320.74 442.77,-326.3"/>+<text xml:space="preserve" text-anchor="start" x="422.98" y="-423.19" font-family="Helvetica,sans-Serif" font-size="11.00" fill="#7ff0c8">owns every side effect:</text>+<text xml:space="preserve" text-anchor="start" x="422.98" y="-411.19" font-family="Helvetica,sans-Serif" font-size="11.00" fill="#7ff0c8">recover here</text>+</g>+<!-- job -->+<g id="node4" class="node">+<title>job</title>+<path fill="#151a24" stroke="#283041" stroke-width="1.3" d="M393.45,-345.68C393.45,-345.68 51,-345.68 51,-345.68 45,-345.68 39,-339.68 39,-333.68 39,-333.68 39,-305.76 39,-305.76 39,-299.76 45,-293.76 51,-293.76 51,-293.76 393.45,-293.76 393.45,-293.76 399.45,-293.76 405.45,-299.76 405.45,-305.76 405.45,-305.76 405.45,-333.68 405.45,-333.68 405.45,-339.68 399.45,-345.68 393.45,-345.68"/>+<text xml:space="preserve" text-anchor="start" x="159.23" y="-320.42" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="14.00" fill="#f4f6fb">durable job attempt</text>+<text xml:space="preserve" text-anchor="start" x="60.6" y="-308.32" font-family="Helvetica,sans-Serif" font-size="12.00" fill="#8a93a6">fail the attempt, the queue retries from the last committed step</text>+</g>+<!-- req->job -->+<g id="edge3" class="edge">+<title>req->job</title>+<path fill="none" stroke="#5a6374" stroke-width="1.4" d="M222.23,-395.17C222.23,-383.42 222.23,-369.28 222.23,-356.49"/>+<polygon fill="#5a6374" stroke="#5a6374" stroke-width="1.4" points="225.2,-356.76 222.23,-348.27 219.25,-356.77 225.2,-356.76"/>+<text xml:space="preserve" text-anchor="middle" x="274.73" y="-369.23" font-family="Helvetica,sans-Serif" font-size="11.00" fill="#8a93a6">  side effects survive it</text>+</g>+<!-- req->ok -->+<g id="edge8" class="edge">+<title>req:e->ok:w</title>+<path fill="none" stroke="#22e0a8" stroke-width="1.4" d="M401.58,-421.64C426.67,-421.64 407.22,-390.24 418.23,-367.68 427.83,-347.98 426.51,-327.38 441.47,-321.42"/>+<polygon fill="#22e0a8" stroke="#22e0a8" stroke-width="1.4" points="441.64,-324.41 449.54,-320.07 440.66,-318.54 441.64,-324.41"/>+</g>+<!-- worker -->+<g id="node5" class="node">+<title>worker</title>+<path fill="#151a24" stroke="#283041" stroke-width="1.3" d="M432.45,-243.76C432.45,-243.76 12,-243.76 12,-243.76 6,-243.76 0,-237.76 0,-231.76 0,-231.76 0,-203.84 0,-203.84 0,-197.84 6,-191.84 12,-191.84 12,-191.84 432.45,-191.84 432.45,-191.84 438.45,-191.84 444.45,-197.84 444.45,-203.84 444.45,-203.84 444.45,-231.76 444.45,-231.76 444.45,-237.76 438.45,-243.76 432.45,-243.76"/>+<text xml:space="preserve" text-anchor="start" x="199.73" y="-218.5" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="14.00" fill="#f4f6fb">worker</text>+<text xml:space="preserve" text-anchor="start" x="21.6" y="-206.4" font-family="Helvetica,sans-Serif" font-size="12.00" fill="#8a93a6">the goroutine catches its own panic, a supervisor goroutine starts a new one</text>+</g>+<!-- job->worker -->+<g id="edge4" class="edge">+<title>job->worker</title>+<path fill="none" stroke="#5a6374" stroke-width="1.4" d="M222.23,-293.25C222.23,-281.5 222.23,-267.36 222.23,-254.57"/>+<polygon fill="#5a6374" stroke="#5a6374" stroke-width="1.4" points="225.2,-254.84 222.23,-246.35 219.25,-254.85 225.2,-254.84"/>+<text xml:space="preserve" text-anchor="middle" x="274.73" y="-261.31" font-family="Helvetica,sans-Serif" font-size="11.00" fill="#8a93a6">  side effects survive it</text>+</g>+<!-- job->ok -->+<g id="edge9" class="edge">+<title>job:e->ok:w</title>+<path fill="none" stroke="#22e0a8" stroke-width="1.4" d="M405.45,-319.72C421.99,-319.72 428.75,-319.72 441.16,-319.72"/>+<polygon fill="#22e0a8" stroke="#22e0a8" stroke-width="1.4" points="442.01,-322.7 450.51,-319.72 442.01,-316.75 442.01,-322.7"/>+</g>+<!-- proc -->+<g id="node6" class="node">+<title>proc</title>+<path fill="#1b1115" stroke="#ff5a5f" stroke-width="1.3" d="M399.83,-147.84C399.83,-147.84 44.62,-147.84 44.62,-147.84 38.62,-147.84 32.63,-141.84 32.63,-135.84 32.63,-135.84 32.63,-107.92 32.63,-107.92 32.63,-101.92 38.63,-95.92 44.63,-95.92 44.63,-95.92 399.83,-95.92 399.83,-95.92 405.83,-95.92 411.83,-101.92 411.83,-107.92 411.83,-107.92 411.83,-135.84 411.83,-135.84 411.83,-141.84 405.83,-147.84 399.83,-147.84"/>+<text xml:space="preserve" text-anchor="start" x="196.35" y="-122.58" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="14.00" fill="#f4f6fb">process</text>+<text xml:space="preserve" text-anchor="start" x="54.23" y="-110.48" font-family="Helvetica,sans-Serif" font-size="12.00" fill="#ff9a9d">exit with a nonzero status, nothing smaller could be proven safe</text>+</g>+<!-- worker->proc -->+<g id="edge5" class="edge">+<title>worker->proc</title>+<path fill="none" stroke="#5a6374" stroke-width="1.4" d="M222.23,-191.63C222.23,-181.61 222.23,-169.88 222.23,-158.98"/>+<polygon fill="#5a6374" stroke="#5a6374" stroke-width="1.4" points="225.2,-159.06 222.23,-150.56 219.25,-159.06 225.2,-159.06"/>+<text xml:space="preserve" text-anchor="middle" x="274.73" y="-165.39" font-family="Helvetica,sans-Serif" font-size="11.00" fill="#8a93a6">  side effects survive it</text>+</g>+<!-- worker->ok -->+<g id="edge10" class="edge">+<title>worker:e->ok:w</title>+<path fill="none" stroke="#22e0a8" stroke-width="1.4" d="M445.45,-217.8C486.22,-217.8 422.09,-300.07 441.55,-316.78"/>+<polygon fill="#22e0a8" stroke="#22e0a8" stroke-width="1.4" points="440.6,-319.6 449.59,-319.13 442.26,-313.89 440.6,-319.6"/>+</g>+<!-- sup -->+<g id="node7" class="node">+<title>sup</title>+<path fill="#0c1714" stroke="#22e0a8" stroke-width="1.3" d="M392.33,-51.92C392.33,-51.92 52.12,-51.92 52.12,-51.92 46.13,-51.92 40.13,-45.92 40.13,-39.92 40.13,-39.92 40.13,-12 40.13,-12 40.13,-6 46.13,0 52.13,0 52.13,0 392.33,0 392.33,0 398.33,0 404.33,-6 404.33,-12 404.33,-12 404.33,-39.92 404.33,-39.92 404.33,-45.92 398.33,-51.92 392.33,-51.92"/>+<text xml:space="preserve" text-anchor="start" x="187.73" y="-26.66" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="14.00" fill="#f4f6fb">supervisor</text>+<text xml:space="preserve" text-anchor="start" x="61.73" y="-14.56" font-family="Helvetica,sans-Serif" font-size="12.00" fill="#7ff0c8">systemd · Docker · kubelet start a clean process, with backoff</text>+</g>+<!-- proc->sup -->+<g id="edge6" class="edge">+<title>proc->sup</title>+<path fill="none" stroke="#ff5a5f" stroke-width="1.4" d="M222.23,-95.71C222.23,-85.69 222.23,-73.96 222.23,-63.06"/>+<polygon fill="#ff5a5f" stroke="#ff5a5f" stroke-width="1.4" points="225.2,-63.14 222.23,-54.64 219.25,-63.14 225.2,-63.14"/>+<text xml:space="preserve" text-anchor="middle" x="240.23" y="-69.47" font-family="Helvetica,sans-Serif" font-size="11.00" fill="#ff8a8d">  exit(1)</text>+</g>+</g>+</svg>diff --git a/website/public/blog/reliable-apps-crash-so-why-does-go-recover-panics/og-recovery-boundaries.png b/website/public/blog/reliable-apps-crash-so-why-does-go-recover-panics/og-recovery-boundaries.pngnew file mode 100644index 00000000..53af2f86Binary files /dev/null and b/website/public/blog/reliable-apps-crash-so-why-does-go-recover-panics/og-recovery-boundaries.png differdiff --git a/website/public/blog/reliable-apps-crash-so-why-does-go-recover-panics/og.png b/website/public/blog/reliable-apps-crash-so-why-does-go-recover-panics/og.pngnew file mode 100644index 00000000..83d9dccdBinary files /dev/null and b/website/public/blog/reliable-apps-crash-so-why-does-go-recover-panics/og.png differdiff --git a/website/public/blog/reliable-apps-crash-so-why-does-go-recover-panics/recovery-boundaries.svg b/website/public/blog/reliable-apps-crash-so-why-does-go-recover-panics/recovery-boundaries.svgnew file mode 100644index 00000000..4018e699--- /dev/null+++ b/website/public/blog/reliable-apps-crash-so-why-does-go-recover-panics/recovery-boundaries.svg@@ -0,0 +1,3 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">+<svg xmlns="http://www.w3.org/2000/svg" style="background: transparent; background-color: transparent;" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="1201px" height="631px" viewBox="0 0 1201 631"><defs/><g><g data-cell-id="0"><g data-cell-id="1"><g data-cell-id="bg"><g><rect x="0" y="0" width="1200" height="630" fill="#0a0d14" stroke="none" pointer-events="all" style="fill: rgb(10, 13, 20);"/></g></g><g data-cell-id="eyebrow"><g><rect x="60" y="26" width="400" height="24" fill="none" stroke="none" pointer-events="all"/></g><g><g fill="#5a6374" font-family="Helvetica, Arial, sans-serif" text-anchor="start" font-size="13px" style="fill: rgb(90, 99, 116);"><text x="62" y="43.5">RECOVERY BOUNDARIES</text></g></g></g><g data-cell-id="process"><g><rect x="60" y="70" width="740" height="500" rx="20" ry="20" fill="#0d1119" stroke="#2c3446" stroke-width="1.5" pointer-events="all" style="fill: rgb(13, 17, 25); stroke: rgb(44, 52, 70);"/></g></g><g data-cell-id="process-t"><g><rect x="60" y="78" width="740" height="26" fill="none" stroke="none" pointer-events="all"/></g><g><g fill="#c9d0dd" font-family="Helvetica, Arial, sans-serif" font-weight="bold" text-anchor="middle" font-size="17px" style="fill: rgb(201, 208, 221);"><text x="430" y="98.5">process</text></g></g></g><g data-cell-id="worker"><g><rect x="106" y="116" width="648" height="408" rx="16.32" ry="16.32" fill="#10151f" stroke="#2f3849" stroke-width="1.5" pointer-events="all" style="fill: rgb(16, 21, 31); stroke: rgb(47, 56, 73);"/></g></g><g data-cell-id="worker-t"><g><rect x="106" y="124" width="648" height="26" fill="none" stroke="none" pointer-events="all"/></g><g><g fill="#c9d0dd" font-family="Helvetica, Arial, sans-serif" font-weight="bold" text-anchor="middle" font-size="17px" style="fill: rgb(201, 208, 221);"><text x="430" y="144.5">worker</text></g></g></g><g data-cell-id="job"><g><rect x="152" y="162" width="556" height="316" rx="12.64" ry="12.64" fill="#141a25" stroke="#353e50" stroke-width="1.5" pointer-events="all" style="fill: rgb(20, 26, 37); stroke: rgb(53, 62, 80);"/></g></g><g data-cell-id="job-t"><g><rect x="152" y="170" width="556" height="26" fill="none" stroke="none" pointer-events="all"/></g><g><g fill="#c9d0dd" font-family="Helvetica, Arial, sans-serif" font-weight="bold" text-anchor="middle" font-size="17px" style="fill: rgb(201, 208, 221);"><text x="430" y="190.5">durable job attempt</text></g></g></g><g data-cell-id="request"><g><rect x="198" y="208" width="464" height="224" rx="8.96" ry="8.96" fill="#181f2b" stroke="#3c4557" stroke-width="1.5" pointer-events="all" style="fill: rgb(24, 31, 43); stroke: rgb(60, 69, 87);"/></g></g><g data-cell-id="request-t"><g><rect x="198" y="216" width="464" height="26" fill="none" stroke="none" pointer-events="all"/></g><g><g fill="#f4f6fb" font-family="Helvetica, Arial, sans-serif" font-weight="bold" text-anchor="middle" font-size="17px" style="fill: rgb(244, 246, 251);"><text x="430" y="236.5">request</text></g></g></g><g data-cell-id="operation"><g><rect x="244" y="254" width="372" height="132" rx="5.28" ry="5.28" fill="#1b1115" stroke="#ff5a5f" stroke-width="1.5" pointer-events="all" style="fill: rgb(27, 17, 21); stroke: rgb(255, 90, 95);"/></g></g><g data-cell-id="operation-t"><g><rect x="244" y="262" width="372" height="26" fill="none" stroke="none" pointer-events="all"/></g><g><g fill="#ff9a9d" font-family="Helvetica, Arial, sans-serif" font-weight="bold" text-anchor="middle" font-size="17px" style="fill: rgb(255, 154, 157);"><text x="430" y="282.5">operation</text></g></g></g><g data-cell-id="glow"><g><ellipse cx="430" cy="322" rx="160" ry="38" fill-opacity="0.12" fill="#ff5a5f" stroke="none" pointer-events="all" style="fill: rgb(255, 90, 95);"/></g></g><g data-cell-id="panic"><g><rect x="360" y="300" width="140" height="44" rx="22" ry="22" fill="#2a1418" stroke="#ff5a5f" stroke-width="1.5" pointer-events="all" style="fill: rgb(42, 20, 24); stroke: rgb(255, 90, 95);"/></g><g><g fill="#ff9a9d" font-family="Helvetica, Arial, sans-serif" font-weight="bold" text-anchor="middle" font-size="18px" style="fill: rgb(255, 154, 157);"><text x="430" y="330">panic()</text></g></g></g><g data-cell-id="unwind"><g><path d="M 500 322 L 800 322" fill="none" stroke="#ff5a5f" stroke-width="2" stroke-miterlimit="10" stroke-dasharray="12 10" pointer-events="stroke" style="stroke: rgb(255, 90, 95);"/></g></g><g data-cell-id="m1"><g><ellipse cx="616" cy="322" rx="7" ry="7" fill="#0a0d14" stroke="#22e0a8" stroke-width="1.5" pointer-events="all" style="fill: rgb(10, 13, 20); stroke: rgb(34, 224, 168);"/></g></g><g data-cell-id="m2"><g><ellipse cx="662" cy="322" rx="7" ry="7" fill="#0a0d14" stroke="#22e0a8" stroke-width="1.5" pointer-events="all" style="fill: rgb(10, 13, 20); stroke: rgb(34, 224, 168);"/></g></g><g data-cell-id="m3"><g><ellipse cx="708" cy="322" rx="7" ry="7" fill="#0a0d14" stroke="#22e0a8" stroke-width="1.5" pointer-events="all" style="fill: rgb(10, 13, 20); stroke: rgb(34, 224, 168);"/></g></g><g data-cell-id="m4"><g><ellipse cx="754" cy="322" rx="7" ry="7" fill="#0a0d14" stroke="#22e0a8" stroke-width="1.5" pointer-events="all" style="fill: rgb(10, 13, 20); stroke: rgb(34, 224, 168);"/></g></g><g data-cell-id="exit"><g><path d="M 800 322 L 929.76 322" fill="none" stroke="#ff5a5f" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke" style="stroke: rgb(255, 90, 95);"/><path d="M 937.76 322 L 929.76 326 L 929.76 318 Z" fill="#ff5a5f" stroke="#ff5a5f" stroke-width="2" stroke-miterlimit="10" pointer-events="all" style="fill: rgb(255, 90, 95); stroke: rgb(255, 90, 95);"/></g><g><g fill="#ff8a8d" font-family="Helvetica, Arial, sans-serif" text-anchor="middle" font-size="14px" style="fill: rgb(255, 138, 141);"><text x="870" y="316">exit(1)</text></g></g></g><g data-cell-id="restart"><g><path d="M 940 362 L 810.24 362" fill="none" stroke="#22e0a8" stroke-width="2" stroke-miterlimit="10" pointer-events="stroke" style="stroke: rgb(34, 224, 168);"/><path d="M 802.24 362 L 810.24 358 L 810.24 366 Z" fill="#22e0a8" stroke="#22e0a8" stroke-width="2" stroke-miterlimit="10" pointer-events="all" style="fill: rgb(34, 224, 168); stroke: rgb(34, 224, 168);"/></g><g><g fill="#7ff0c8" font-family="Helvetica, Arial, sans-serif" text-anchor="middle" font-size="14px" style="fill: rgb(127, 240, 200);"><text x="870" y="380">clean process</text></g></g></g><g data-cell-id="supervisor"><g><rect x="940" y="278" width="210" height="128" rx="10.24" ry="10.24" fill="#0c1714" stroke="#22e0a8" stroke-width="1.5" pointer-events="all" style="fill: rgb(12, 23, 20); stroke: rgb(34, 224, 168);"/></g></g><g data-cell-id="supervisor-t"><g><rect x="940" y="308" width="210" height="28" fill="none" stroke="none" pointer-events="all"/></g><g><g fill="#f4f6fb" font-family="Helvetica, Arial, sans-serif" font-weight="bold" text-anchor="middle" font-size="18px" style="fill: rgb(244, 246, 251);"><text x="1045" y="330">supervisor</text></g></g></g><g data-cell-id="supervisor-s"><g><rect x="940" y="338" width="210" height="24" fill="none" stroke="none" pointer-events="all"/></g><g><g fill="#7ff0c8" font-family="Helvetica, Arial, sans-serif" text-anchor="middle" font-size="13px" style="fill: rgb(127, 240, 200);"><text x="1045" y="355.5">systemd · Docker · kubelet</text></g></g></g></g></g></g></svg>\ No newline at end of filediff --git a/website/public/blog/reliable-apps-crash-so-why-does-go-recover-panics/restaurant-vs-go-service.svg b/website/public/blog/reliable-apps-crash-so-why-does-go-recover-panics/restaurant-vs-go-service.svgnew file mode 100644index 00000000..fb8f7bdc--- /dev/null+++ b/website/public/blog/reliable-apps-crash-so-why-does-go-recover-panics/restaurant-vs-go-service.svg@@ -0,0 +1 @@+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1200 630" width="1200" height="630" role="img" font-family="Inter, -apple-system, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif"><defs><style>@font-face{font-family:'Inter';font-weight:100 900;font-style:normal;src:url(data:font/woff2;base64,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) format('woff2')}@font-face{font-family:'JetBrains Mono';font-weight:700;font-style:normal;src:url(data:font/woff2;base64,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) format('woff2')}</style><marker id="arrow" viewBox="0 0 10 10" refX="8" refY="5" markerWidth="7" markerHeight="7" orient="auto-start-reverse"><path d="M 0 0 L 10 5 L 0 10 z" fill="#5a6374"></path></marker></defs><rect x="0" y="0" width="1200" height="630" fill="#0a0d14"></rect><text x="44" y="40" font-size="12" font-weight="700" fill="#5a6374" text-anchor="start" font-family="'JetBrains Mono', ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" letter-spacing="1.6">RELIABLE APPS CRASH. THE GOOD ONES COME BACK CLEAN.</text><line x1="600" y1="84" x2="600" y2="488" stroke="#283041" stroke-width="1.5"></line><g><rect x="44" y="60" width="548" height="452" rx="18" fill="#10151f" stroke="#283041" stroke-width="1.5"></rect><rect x="205.7109375" y="80" width="224.578125" height="54" rx="27" fill="#241b16" stroke="#5a3d2a" stroke-width="1.5"></rect><text x="318" y="117" font-size="28" font-weight="700" fill="#ffcfa8" text-anchor="middle" font-family="'JetBrains Mono', ui-monospace, SFMono-Regular, Menlo, Consolas, monospace">Restaurant</text><text x="318" y="174" font-size="21" font-weight="500" fill="#8a93a6" text-anchor="middle">The fridge broke and stayed warm all night.</text><rect x="76" y="198" width="484" height="76" rx="12" fill="#1b1115" stroke="#ff5a5f" stroke-width="1.5"></rect><text x="318" y="230.5" font-size="22" font-weight="500" fill="#ffb1b3" text-anchor="middle">Close the doors, throw out</text><text x="318" y="257.5" font-size="22" font-weight="500" fill="#ffb1b3" text-anchor="middle">everything you can't trust</text><line x1="318" y1="278" x2="318" y2="300" stroke="#5a6374" stroke-width="1.6" marker-end="url(#arrow)"></line><rect x="76" y="306" width="484" height="76" rx="12" fill="#0d1a26" stroke="#00d4ff" stroke-width="1.5"></rect><text x="318" y="352" font-size="22" font-weight="500" fill="#9fe6ff" text-anchor="middle">Restock from a supplier you trust</text><line x1="318" y1="386" x2="318" y2="408" stroke="#5a6374" stroke-width="1.6" marker-end="url(#arrow)"></line><rect x="76" y="414" width="484" height="76" rx="12" fill="#0c1714" stroke="#22e0a8" stroke-width="1.5"></rect><text x="318" y="460" font-size="22" font-weight="500" fill="#7ff0c8" text-anchor="middle">Seat guests again</text></g><g><rect x="608" y="60" width="548" height="452" rx="18" fill="#10151f" stroke="#283041" stroke-width="1.5"></rect><rect x="769.7109375" y="80" width="224.578125" height="54" rx="27" fill="#141d30" stroke="#2c4a7a" stroke-width="1.5"></rect><text x="882" y="117" font-size="28" font-weight="700" fill="#aecbff" text-anchor="middle" font-family="'JetBrains Mono', ui-monospace, SFMono-Regular, Menlo, Consolas, monospace">Go service</text><text x="882" y="174" font-size="21" font-weight="500" fill="#8a93a6" text-anchor="middle">A panic landed between two writes.</text><rect x="640" y="198" width="484" height="76" rx="12" fill="#1b1115" stroke="#ff5a5f" stroke-width="1.5"></rect><text x="882" y="244" font-size="22" font-weight="500" fill="#ffb1b3" text-anchor="middle">exit(1), nothing in memory survives</text><line x1="882" y1="278" x2="882" y2="300" stroke="#5a6374" stroke-width="1.6" marker-end="url(#arrow)"></line><rect x="640" y="306" width="484" height="76" rx="12" fill="#0d1a26" stroke="#00d4ff" stroke-width="1.5"></rect><text x="882" y="338.5" font-size="22" font-weight="500" fill="#9fe6ff" text-anchor="middle">The supervisor starts a clean process</text><text x="882" y="365.5" font-size="22" font-weight="500" fill="#9fe6ff" text-anchor="middle">that rebuilds from durable state</text><line x1="882" y1="386" x2="882" y2="408" stroke="#5a6374" stroke-width="1.6" marker-end="url(#arrow)"></line><rect x="640" y="414" width="484" height="76" rx="12" fill="#0c1714" stroke="#22e0a8" stroke-width="1.5"></rect><text x="882" y="460" font-size="22" font-weight="500" fill="#7ff0c8" text-anchor="middle">Readiness passes, traffic comes back</text></g><text x="131.265625" y="579" font-size="19" font-weight="500" fill="#c9d0dd" text-anchor="start">Stop and discard what you can't trust</text><text x="522.234375" y="579" font-size="19" font-weight="500" fill="#c9d0dd" text-anchor="start">Rebuild from a source you trust</text><text x="866.25" y="579" font-size="19" font-weight="500" fill="#c9d0dd" text-anchor="start">Serve again, invariants hold</text><rect x="99.265625" y="562" width="20" height="20" rx="5" fill="#1b1115" stroke="#ff5a5f" stroke-width="1.5"></rect><rect x="490.234375" y="562" width="20" height="20" rx="5" fill="#0d1a26" stroke="#00d4ff" stroke-width="1.5"></rect><rect x="834.25" y="562" width="20" height="20" rx="5" fill="#0c1714" stroke="#22e0a8" stroke-width="1.5"></rect></svg>\ No newline at end of file