mq-bridge-py-basic 0.2.17__tar.gz → 0.2.19__tar.gz

{mq_bridge_py_basic-0.2.17 → mq_bridge_py_basic-0.2.19}/Cargo.lock

@@ -3057,9 +3057,10 @@ dependencies = [
 
 [[package]]
 name = "mq-bridge"
-version = "0.2.17"
+version = "0.2.19"
 dependencies = [
  "anyhow",
+ "arc-swap",
  "async-channel",
  "async-nats",
  "async-trait",
@@ -3123,7 +3124,7 @@ dependencies = [
 
 [[package]]
 name = "mq-bridge-py"
-version = "0.2.17"
+version = "0.2.19"
 dependencies = [
  "anyhow",
  "async-trait",

{mq_bridge_py_basic-0.2.17 → mq_bridge_py_basic-0.2.19}/Cargo.toml

@@ -16,7 +16,7 @@ members = ["python/mq-bridge-py"]
 resolver = "2"
 
 [workspace.package]
-version = "0.2.17"
+version = "0.2.19"
 
 [workspace.dependencies]
 anyhow = "1.0"
@@ -26,7 +26,7 @@ fast-uuid-v7 = "0.1.5"
 serde = "1.0"
 serde_json = "1.0"
 serde_yaml_ng = "0.10"
-tokio = "1"
+tokio = "1.34"  # `Receiver::recv_many` (HTTP source batch drain) needs 1.34+.
 tracing = "0.1"
 
 [profile.release]
@@ -109,6 +109,7 @@ rumqttc = { version = "0.25", default-features = false, features = ["use-rustls-
 mqi = { version = "0.3", optional = true }
 
 # HTTP
+arc-swap = { version = "1", optional = true }
 hyper = { version = "1.8", optional = true, features = ["client", "server", "http1", "http2"] }
 hyper-util = { version = "0.1", optional = true, features = ["tokio", "client", "client-legacy", "server", "http1", "http2"] }
 hyper-rustls = { version = "0.27", optional = true, default-features = false, features = ["http1", "http2", "tls12", "logging", "native-tokio"] }
@@ -178,7 +179,7 @@ amqp = ["lapin", "rustls", "rustls-pemfile", "url"]
 nats = ["async-nats", "rustls", "rustls-pemfile"]
 mongodb = ["dep:mongodb"]
 mqtt = ["rumqttc", "rustls", "tokio-rustls", "rustls-pemfile", "url"]
-http = ["hyper", "hyper-util", "hyper-rustls", "http-body-util", "dep:http-body", "rustls", "tokio-rustls", "rustls-pemfile", "webpki-roots", "h2", "dep:flate2", "dep:base64"]
+http = ["dep:arc-swap", "hyper", "hyper-util", "hyper-rustls", "http-body-util", "dep:http-body", "rustls", "tokio-rustls", "rustls-pemfile", "webpki-roots", "h2", "dep:flate2", "dep:base64"]
 websocket = ["dep:tokio-tungstenite"]
 aws = ["aws-config", "aws-sdk-sqs", "aws-sdk-sns", "dep:base64"]
 ibm-mq = ["mqi"]
@@ -194,6 +195,8 @@ tempfile = "3.10"
 chrono = "0.4"
 metrics-util = "0.20"
 criterion = { version = "0.8", features = ["async", "async_tokio"] }
+# Used by the router_bench microbench to model the proposed lock-free route table.
+arc-swap = "1"
 mq-bridge = { path = ".", features = ["test-utils", "rustls-ring"] }
 reqwest = { version = "0.13", features = ["stream"] }
 
@@ -207,6 +210,12 @@ name = "performance_bench"
 harness = false
 required-features = ["test-utils"]
 
+# Isolates the per-request HTTP route lookup (Mutex<HashMap> vs ArcSwap).
+# No external services or features required.
+[[bench]]
+name = "router_bench"
+harness = false
+
 [[test]]
 name = "integration_test"
 required-features = ["test-utils"]

{mq_bridge_py_basic-0.2.17 → mq_bridge_py_basic-0.2.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mq-bridge-py-basic
-Version: 0.2.17
+Version: 0.2.19
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3

mq_bridge_py_basic-0.2.19/benches/router_bench.rs

@@ -0,0 +1,275 @@
+//! Microbenchmark isolating HTTP route lookup — bottleneck #1 from the
+//! throughput analysis.
+//!
+//! `SharedHttpRouter::match_route` (src/endpoints/http.rs) takes a blocking
+//! `std::sync::Mutex` over a `HashMap` and linearly scans it on EVERY request.
+//! This bench reproduces that exact access pattern in isolation and compares it
+//! with two lock-free alternatives, so we can see — before touching production
+//! code — whether the per-request router lock is what caps multicore scaling:
+//!
+//!   * `mutex_hashmap`  — current design: `Mutex<HashMap>` + scan + `Arc` clone
+//!   * `arcswap_vec`    — proposed: `ArcSwap<Vec<..>>` snapshot + scan + `Arc` clone
+//!   * `arcswap_single` — proposed fast path for the common single-route server
+//!
+//! Each is measured single-threaded (latency) and under N-thread contention
+//! (aggregate throughput). The hypothesis is confirmed if the mutex variant
+//! collapses as threads are added while the ArcSwap variants stay flat.
+//!
+//! Run with: `cargo bench --bench router_bench`
+
+use arc_swap::{ArcSwap, ArcSwapOption};
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use std::collections::HashMap;
+use std::hint::black_box;
+use std::sync::{Arc, Barrier, Mutex};
+use std::thread;
+use std::time::{Duration, Instant};
+
+/// Stand-in for `HttpConsumerState`: the two fields `match_route` actually reads,
+/// plus padding so the `Arc` payload is a realistic size (the real struct holds a
+/// channel sender, a semaphore, several strings, etc.). The padding keeps the
+/// comparison honest — a trivially tiny `Arc` would understate clone/cache costs.
+struct RouteState {
+    path: Option<String>,
+    method: Option<&'static str>,
+    id: u64,
+    _padding: [u64; 8],
+}
+
+impl RouteState {
+    fn new(id: u64, path: Option<&str>, method: Option<&'static str>) -> Arc<Self> {
+        Arc::new(Self {
+            path: path.map(String::from),
+            method,
+            id,
+            _padding: [0; 8],
+        })
+    }
+}
+
+fn route_matches_path(state: &RouteState, path: &str) -> bool {
+    match &state.path {
+        Some(route_path) => route_path == path,
+        None => true,
+    }
+}
+
+fn route_matches_method(state: &RouteState, method: &str) -> bool {
+    match state.method {
+        Some(route_method) => route_method == method,
+        None => true,
+    }
+}
+
+fn route_specificity(state: &RouteState) -> (u8, u8) {
+    (
+        u8::from(state.path.is_some()),
+        u8::from(state.method.is_some()),
+    )
+}
+
+/// Faithful copy of `match_route`'s best-specificity scan.
+fn scan<'a, I>(routes: I, path: &str, method: &str) -> Option<Arc<RouteState>>
+where
+    I: Iterator<Item = &'a Arc<RouteState>>,
+{
+    let mut best: Option<Arc<RouteState>> = None;
+    let mut best_specificity = (0u8, 0u8);
+    for state in routes {
+        if !route_matches_path(state, path) {
+            continue;
+        }
+        if route_matches_method(state, method) {
+            let specificity = route_specificity(state);
+            if best.is_none() || specificity > best_specificity {
+                best_specificity = specificity;
+                best = Some(Arc::clone(state));
+            }
+        }
+    }
+    best
+}
+
+/// Current production design: blocking lock + `HashMap` scan per lookup.
+struct MutexRouter {
+    routes: Mutex<HashMap<u64, Arc<RouteState>>>,
+}
+impl MutexRouter {
+    fn lookup(&self, path: &str, method: &str) -> Option<Arc<RouteState>> {
+        let routes = self.routes.lock().unwrap();
+        scan(routes.values(), path, method)
+    }
+}
+
+/// Proposed design: lock-free snapshot + scan (handles multi-route servers).
+struct ArcSwapRouter {
+    routes: ArcSwap<Vec<Arc<RouteState>>>,
+}
+impl ArcSwapRouter {
+    fn lookup(&self, path: &str, method: &str) -> Option<Arc<RouteState>> {
+        let routes = self.routes.load();
+        scan(routes.iter(), path, method)
+    }
+}
+
+/// Proposed fast path for the overwhelmingly common single-route server: a
+/// lock-free pointer load with no scan at all.
+struct ArcSwapSingleRouter {
+    only: ArcSwapOption<RouteState>,
+}
+impl ArcSwapSingleRouter {
+    fn lookup(&self, path: &str, method: &str) -> Option<Arc<RouteState>> {
+        let only = self.only.load_full()?;
+        if route_matches_path(&only, path) && route_matches_method(&only, method) {
+            Some(only)
+        } else {
+            None
+        }
+    }
+}
+
+fn build_routes(n: usize) -> Vec<Arc<RouteState>> {
+    (0..n)
+        .map(|i| RouteState::new(i as u64, Some(&format!("/r{i}")), Some("POST")))
+        .collect()
+}
+
+/// Run `work` on `threads` OS threads, each performing `iters` lookups, started
+/// together via a barrier. Returns wall-clock elapsed for the whole batch.
+///
+/// criterion divides this by `iters`, so with `Throughput::Elements(threads)`
+/// the reported rate is aggregate lookups/sec across all threads — exactly the
+/// number that should plateau if a shared lock is the bottleneck.
+fn contended(threads: usize, iters: u64, work: Arc<dyn Fn() + Send + Sync>) -> Duration {
+    let barrier = Arc::new(Barrier::new(threads + 1));
+    let mut handles = Vec::with_capacity(threads);
+    for _ in 0..threads {
+        let work = Arc::clone(&work);
+        let barrier = Arc::clone(&barrier);
+        handles.push(thread::spawn(move || {
+            barrier.wait();
+            for _ in 0..iters {
+                work();
+            }
+        }));
+    }
+    let start = Instant::now();
+    barrier.wait();
+    for handle in handles {
+        handle.join().unwrap();
+    }
+    start.elapsed()
+}
+
+fn bench_router(c: &mut Criterion) {
+    // A handful of routes so the scan has real work; lookups target the last one
+    // to force a full scan (worst case for the linear-scan designs).
+    let n_routes = 4usize;
+    let target_path = format!("/r{}", n_routes - 1);
+    let single_path = "/only";
+
+    let mutex = Arc::new(MutexRouter {
+        routes: Mutex::new(
+            build_routes(n_routes)
+                .into_iter()
+                .map(|state| (state.id, state))
+                .collect(),
+        ),
+    });
+    let arcswap = Arc::new(ArcSwapRouter {
+        routes: ArcSwap::from_pointee(build_routes(n_routes)),
+    });
+    let single = Arc::new(ArcSwapSingleRouter {
+        only: ArcSwapOption::new(Some(RouteState::new(0, Some(single_path), Some("POST")))),
+    });
+
+    // ---- single-threaded latency ----
+    {
+        let mut group = c.benchmark_group("router_lookup/single_thread");
+        group.throughput(Throughput::Elements(1));
+        group.bench_function("mutex_hashmap", |b| {
+            b.iter(|| black_box(mutex.lookup(black_box(&target_path), black_box("POST"))))
+        });
+        group.bench_function("arcswap_vec", |b| {
+            b.iter(|| black_box(arcswap.lookup(black_box(&target_path), black_box("POST"))))
+        });
+        group.bench_function("arcswap_single", |b| {
+            b.iter(|| black_box(single.lookup(black_box(single_path), black_box("POST"))))
+        });
+        group.finish();
+    }
+
+    // ---- contended aggregate throughput ----
+    let max_threads = thread::available_parallelism()
+        .map(|n| n.get())
+        .unwrap_or(4);
+    let thread_counts: Vec<usize> = {
+        let mut counts = vec![1usize, max_threads / 2, max_threads];
+        counts.retain(|&t| t >= 1);
+        counts.sort_unstable();
+        counts.dedup();
+        counts
+    };
+
+    let mut group = c.benchmark_group("router_lookup/contended");
+    for &threads in &thread_counts {
+        group.throughput(Throughput::Elements(threads as u64));
+
+        group.bench_with_input(
+            BenchmarkId::new("mutex_hashmap", threads),
+            &threads,
+            |b, &t| {
+                b.iter_custom(|iters| {
+                    let router = Arc::clone(&mutex);
+                    let path = target_path.clone();
+                    contended(
+                        t,
+                        iters,
+                        Arc::new(move || {
+                            black_box(router.lookup(&path, "POST"));
+                        }),
+                    )
+                })
+            },
+        );
+
+        group.bench_with_input(
+            BenchmarkId::new("arcswap_vec", threads),
+            &threads,
+            |b, &t| {
+                b.iter_custom(|iters| {
+                    let router = Arc::clone(&arcswap);
+                    let path = target_path.clone();
+                    contended(
+                        t,
+                        iters,
+                        Arc::new(move || {
+                            black_box(router.lookup(&path, "POST"));
+                        }),
+                    )
+                })
+            },
+        );
+
+        group.bench_with_input(
+            BenchmarkId::new("arcswap_single", threads),
+            &threads,
+            |b, &t| {
+                b.iter_custom(|iters| {
+                    let router = Arc::clone(&single);
+                    contended(
+                        t,
+                        iters,
+                        Arc::new(move || {
+                            black_box(router.lookup(single_path, "POST"));
+                        }),
+                    )
+                })
+            },
+        );
+    }
+    group.finish();
+}
+
+criterion_group!(benches, bench_router);
+criterion_main!(benches);

{mq_bridge_py_basic-0.2.17 → mq_bridge_py_basic-0.2.19}/scripts/analysis/http/mq_bridge_http_profile.rs

@@ -136,6 +136,7 @@ enum ProfileMode {
     Immediate,
     Metadata,
     ChannelAck,
+    WorkerLocalAck,
     DirectConsumer,
     DirectConsumerAck,
     DirectConsumerFireForget,
@@ -242,6 +243,7 @@ fn parse_mode(value: &str) -> ProfileMode {
         "immediate" => ProfileMode::Immediate,
         "metadata" => ProfileMode::Metadata,
         "channel-ack" | "channel_ack" => ProfileMode::ChannelAck,
+        "worker-local-ack" | "worker_local_ack" => ProfileMode::WorkerLocalAck,
         "direct-consumer" | "direct_consumer" => ProfileMode::DirectConsumer,
         "direct-consumer-ack" | "direct_consumer_ack" => ProfileMode::DirectConsumerAck,
         "direct-consumer-fire-forget" | "direct_consumer_fire_forget" => {
@@ -283,7 +285,7 @@ fn print_help() {
     eprintln!(
         "Usage: mq_bridge_http_profile [--mode MODE] [--port PORT] [--duration-s SECONDS] [--path PATH]\n\
          Options:\n\
-           --mode MODE                 route | route-fire-forget | route-handler | immediate | metadata | channel-ack | direct-consumer | direct-consumer-ack | direct-consumer-fire-forget | inline-response | inline-body-only (default route)\n\
+           --mode MODE                 route | route-fire-forget | route-handler | immediate | metadata | channel-ack | worker-local-ack | direct-consumer | direct-consumer-ack | direct-consumer-fire-forget | inline-response | inline-body-only (default route)\n\
            --client-url URL            run Rust load client instead of server\n\
            --clients N                 Rust load client concurrency (default 8)\n\
            --header-count N            Add N synthetic request headers in Rust load client (default 0)\n\
@@ -335,6 +337,7 @@ async fn run_standalone_server(args: ProfileArgs) -> anyhow::Result<()> {
     let mode = args.mode;
     let path = Arc::new(args.path.clone());
     let duration_s = args.duration_s;
+    let buffer_size = args.internal_buffer_size;
 
     let shutdown = tokio::time::sleep(std::time::Duration::from_secs(duration_s));
     tokio::pin!(shutdown);
@@ -350,7 +353,21 @@ async fn run_standalone_server(args: ProfileArgs) -> anyhow::Result<()> {
             accepted = listener.accept() => {
                 let (stream, _) = accepted?;
                 let io = TokioIo::new(stream);
-                let tx = channel_tx.clone();
+                // WorkerLocalAck gives every connection its own channel + drain task, so
+                // there is no shared single-receiver contention (variant B in the ladder).
+                // ChannelAck reuses the one process-wide channel (variant C). The
+                // per-request work is otherwise identical, isolating the global funnel.
+                let tx = if mode == ProfileMode::WorkerLocalAck {
+                    let (tx, mut rx) = tokio::sync::mpsc::channel::<AckMessage>(buffer_size);
+                    tokio::spawn(async move {
+                        while let Some((_payload, _metadata, ack)) = rx.recv().await {
+                            let _ = ack.send(());
+                        }
+                    });
+                    Some(tx)
+                } else {
+                    channel_tx.clone()
+                };
                 let path = path.clone();
                 tokio::spawn(async move {
                     let service = service_fn(move |req| {
@@ -479,7 +496,10 @@ async fn profile_request(
             .unwrap());
     }
 
-    let metadata = if matches!(mode, ProfileMode::Metadata | ProfileMode::ChannelAck) {
+    let metadata = if matches!(
+        mode,
+        ProfileMode::Metadata | ProfileMode::ChannelAck | ProfileMode::WorkerLocalAck
+    ) {
         build_metadata(&req)
     } else {
         HashMap::new()
@@ -495,7 +515,7 @@ async fn profile_request(
         }
     };
 
-    if mode == ProfileMode::ChannelAck {
+    if matches!(mode, ProfileMode::ChannelAck | ProfileMode::WorkerLocalAck) {
         let Some(tx) = tx else {
             return Ok(Response::builder()
                 .status(500)

mq_bridge_py_basic-0.2.19/scripts/analysis/http/run_http_ladder.sh

@@ -0,0 +1,87 @@
+#!/usr/bin/env bash
+#
+# HTTP throughput ladder — runs the four benchmark targets from the throughput
+# analysis back-to-back with the same in-tree Rust load client, so each rung adds
+# exactly one layer and the RPS deltas localize the bottleneck.
+#
+#   A  raw-hyper          (immediate)          : Hyper + body read + fixed "ok". Ceiling.
+#   B  worker-local-chan  (worker-local-ack)   : + per-connection mpsc + oneshot ack (no shared receiver)
+#   C  global-channel     (channel-ack)        : + ONE process-wide mpsc + single drain task
+#   Dr router+consumer    (direct-consumer-ack): real HttpConsumer — router Mutex + per-route mpsc
+#   D  full-route         (route-handler)      : full mq-bridge route executor
+#
+# Read the deltas:
+#   A -> B : cost of the per-request channel+ack machinery itself (should be small)
+#   B -> C : cost of funneling every connection through ONE shared receiver  (bottleneck #2)
+#   C -> Dr: cost of the router Mutex + real consumer path                   (bottleneck #1)
+#   Dr -> D: cost of the route executor / worker pool / commit sequencer
+#
+# Caveat: A/B/C use a single-acceptor standalone server; Dr/D use the production
+# SO_REUSEPORT multi-worker accept. Compare within {A,B,C} and within {Dr,D}; the
+# router lock itself is isolated cleanly (no accept-model confound) by
+# `cargo bench --bench router_bench`.
+#
+# Usage:  scripts/analysis/http/run_http_ladder.sh
+# Env:    WORKERS, CLIENTS, DURATION (s), PORT, FEATURES
+set -euo pipefail
+
+cd "$(dirname "$0")/../../.."
+
+FEATURES="${FEATURES:-http,rustls-ring}"
+if command -v nproc >/dev/null 2>&1; then
+  CORES="$(nproc)"
+else
+  CORES="$(sysctl -n hw.ncpu 2>/dev/null || echo 4)"
+fi
+WORKERS="${WORKERS:-$CORES}"
+CLIENTS="${CLIENTS:-$CORES}"
+DURATION="${DURATION:-15}"
+PORT="${PORT:-18080}"
+REQ_PATH="/bench"
+BIN=target/release/mq_bridge_http_profile
+
+echo ">> building release binary (features: $FEATURES)"
+cargo build --release --bin mq_bridge_http_profile --features "$FEATURES" >/dev/null
+
+run_rung() {
+  local label="$1" mode="$2" expect="$3"
+  local log; log="$(mktemp)"
+
+  "$BIN" --mode "$mode" --port "$PORT" --path "$REQ_PATH" \
+    --workers "$WORKERS" --duration-s "$((DURATION + 8))" >"$log" 2>&1 &
+  local server_pid=$!
+
+  # Wait for the server to announce READY (up to ~10s).
+  local ready=0
+  for _ in $(seq 1 100); do
+    if grep -q READY "$log"; then ready=1; break; fi
+    if ! kill -0 "$server_pid" 2>/dev/null; then break; fi
+    sleep 0.1
+  done
+  if [ "$ready" -ne 1 ]; then
+    echo "  [$label] server failed to start:"; sed 's/^/    /' "$log"
+    kill "$server_pid" 2>/dev/null || true; wait "$server_pid" 2>/dev/null || true
+    rm -f "$log"; return 1
+  fi
+
+  local out
+  out="$("$BIN" --client-url "http://127.0.0.1:${PORT}${REQ_PATH}" \
+    --clients "$CLIENTS" --duration-s "$DURATION" --expected-body "$expect" 2>&1 || true)"
+  local rps; rps="$(printf '%s' "$out" | sed -n 's/.*(\([0-9]*\) req\/s).*/\1/p')"
+  printf '  %-22s %12s req/s\n' "$label" "${rps:-FAILED}"
+  if [ -z "$rps" ]; then printf '%s\n' "$out" | sed 's/^/      /'; fi
+
+  kill "$server_pid" 2>/dev/null || true
+  wait "$server_pid" 2>/dev/null || true
+  rm -f "$log"
+
+  if [ -z "$rps" ]; then return 1; fi
+}
+
+echo ">> HTTP throughput ladder (workers=$WORKERS clients=$CLIENTS duration=${DURATION}s)"
+run_rung "A raw-hyper"          immediate           ok
+run_rung "B worker-local-chan"  worker-local-ack    ok
+run_rung "C global-channel"     channel-ack         ok
+run_rung "Dr router+consumer"   direct-consumer-ack message-processed
+run_rung "D full-route"         route-handler       payload
+echo ">> done"

{mq_bridge_py_basic-0.2.17 → mq_bridge_py_basic-0.2.19}/scripts/httparena/README.md

@@ -38,12 +38,13 @@ profiles still run.
 
 ## How it works
 
-- **One AutoBuilder, every HTTP flavour.** mq-bridge's HTTP server uses
+- **Auto for core, explicit H2 for h2c.** mq-bridge's default HTTP server uses
   hyper-util's `AutoBuilder`, which negotiates HTTP/1.1 **and** HTTP/2
   prior-knowledge (h2c) on the same plaintext port. The core `mq-bridge` entry
   binds **8080** (HTTP/1.1 + h2c) and **8443** (HTTP/2 over TLS) in one process,
-  sharing the same handler; `mq-bridge-h2c` is the same dispatch on **8082** for
-  the explicit h2c profiles.
+  sharing the same handler; `mq-bridge-h2c` uses the library's
+  `server_protocol = http2_only` setting on **8082** so HttpArena's explicit
+  h2c profiles cannot fall back to HTTP/1.1.
 - **HTTP/2 over TLS (`baseline-h2`, `static-h2`).** The library advertises ALPN
   `h2` on the TLS listener, so conformant clients negotiate HTTP/2; the TLS route
   reads its cert/key from `/certs/server.crt` + `/certs/server.key` (overridable
@@ -97,7 +98,7 @@ scripts/httparena/frameworks/
 ## Submitting upstream
 
 1. Pin the version: each Rust `Cargo.toml` and the Python `Dockerfile` reference
-   this repo at tag `v0.2.16` — bump to the release you want to benchmark.
+   this repo at tag `v0.2.18` — bump to the release you want to benchmark.
 2. Fork `MDA2AV/HttpArena` and copy each `scripts/httparena/frameworks/<name>/`
    into the fork's `frameworks/<name>/`.
 3. On the PR, validate and benchmark per framework:

{mq_bridge_py_basic-0.2.17 → mq_bridge_py_basic-0.2.19}/scripts/httparena/frameworks/mq-bridge-py/Dockerfile

@@ -5,7 +5,7 @@
 # the compiled extension ABI matches. Pin MQB_REF to a released tag.
 FROM python:3.12-slim AS build
 
-ARG MQB_REF=v0.2.16
+ARG MQB_REF=v0.2.18
 RUN apt-get update \
     && apt-get install -y --no-install-recommends curl build-essential git ca-certificates \
     && rm -rf /var/lib/apt/lists/*

{mq_bridge_py_basic-0.2.17 → mq_bridge_py_basic-0.2.19}/scripts/techempower/Python/mq-bridge-py/mq-bridge-py.dockerfile

@@ -5,7 +5,7 @@
 # matches. For the upstream PR, pin MQB_REF to a released tag.
 FROM python:3.12-slim AS build
 
-ARG MQB_REF=v0.2.16
+ARG MQB_REF=v0.2.18
 RUN apt-get update \
     && apt-get install -y --no-install-recommends curl build-essential git ca-certificates \
     && rm -rf /var/lib/apt/lists/*

{mq_bridge_py_basic-0.2.17 → mq_bridge_py_basic-0.2.19}/scripts/the-benchmarker/README.md

@@ -45,7 +45,7 @@ installs Rust + maturin and builds `mq_bridge_py` from this repo at the pinned
 ## Submitting upstream
 
 1. Pin the version: the Rust `Cargo.toml` and Python `config.yaml` reference this
-   repo at tag `v0.2.16` — bump to the release you want to benchmark.
+   repo at tag `v0.2.18` — bump to the release you want to benchmark.
 2. Fork `the-benchmarker/web-frameworks` and copy:
    - `scripts/the-benchmarker/rust/mq-bridge/`      → `rust/mq-bridge/`
    - `scripts/the-benchmarker/python/mq-bridge-py/` → `python/mq-bridge-py/`

{mq_bridge_py_basic-0.2.17 → mq_bridge_py_basic-0.2.19}/scripts/the-benchmarker/python/mq-bridge-py/config.yaml

@@ -24,7 +24,7 @@ framework:
   bootstrap:
     - curl https://sh.rustup.rs -sSf | sh -s -- -y --profile minimal
     - . "$HOME/.cargo/env" && pip install maturin
-    - git clone --depth 1 -b v0.2.16 https://github.com/marcomq/mq-bridge /tmp/mqb
+    - git clone --depth 1 -b v0.2.18 https://github.com/marcomq/mq-bridge /tmp/mqb
     - . "$HOME/.cargo/env" && cd /tmp/mqb/python/mq-bridge-py && maturin build --release --no-default-features -F http -F pyo3/extension-module -o /tmp/wheels
     - pip install /tmp/wheels/*.whl