raptor 0.16.1 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e564259e8919bb36ded41097d9f3930fcf6ad2f2d090cd4bf0a2ef4cbf424b4
-  data.tar.gz: 1bf2f2e1077af1c2b61ba4b52bd5b13460bf0f27105a355b5dc01ff05e62b7b8
+  metadata.gz: fbd24155ed44e8b8faf1f5b11a6078a34ab58bf43c290f3ffcf2a4a582c74d16
+  data.tar.gz: 7d6a0f38240c4ae3e723650fcd7a9888f2b59b69f3145018a918524565324972
 SHA512:
-  metadata.gz: 103f96d2f2490ea4bd1f844f29a8980deba5881e52b3c684ec2db963c0b0b0d426d616ce66ff22be93736550583891862502c1216663426249e015e1c68ab29d
-  data.tar.gz: e377a59417305334b255cf08be1c8c257971840d244b8b14b461ebbdfb857dc5a8cfbd6d37bee26ab2dc95642601bd1b7640100277c0b401f225fab66bbf8c77
+  metadata.gz: 811414a1f6a2469ef38c20935564ba204efdc5988437be5d0fa8a167d85a42204abe2a743115d090b24cf2cc8489e8dffdf57a93c1313936dcfa04a7d2213768
+  data.tar.gz: 29a62a959b22ca99c55eea39919d8fe3618fdb5061054718c38503c658c803d77a3a2b40cc9b8089da917faf4041569545073c24c468f6e8552f0d113ee0d469

data/.buildkite/pipeline.yml

@@ -41,7 +41,7 @@ steps:
         soft_fail: true
         image: "rubylang/ruby:master-dev"
         commands:
-          - apt-get update && apt-get install -y libyaml-dev
+          - apt-get update && apt-get install -y libyaml-dev libssl-dev
           - ruby -v
           - bundle install
           - bundle exec rake ci
@@ -52,7 +52,7 @@ steps:
         env:
           RUBY_YJIT_ENABLE: "1"
         commands:
-          - apt-get update && apt-get install -y libyaml-dev
+          - apt-get update && apt-get install -y libyaml-dev libssl-dev
           - ruby -v
           - bundle install
           - bundle exec rake ci
@@ -63,7 +63,7 @@ steps:
         env:
           RUBY_GC_STRESS: "1"
         commands:
-          - apt-get update && apt-get install -y libyaml-dev
+          - apt-get update && apt-get install -y libyaml-dev libssl-dev
           - ruby -v
           - bundle install
           - bundle exec rake ci
@@ -75,7 +75,7 @@ steps:
           RUBY_YJIT_ENABLE: "1"
           RUBY_GC_STRESS: "1"
         commands:
-          - apt-get update && apt-get install -y libyaml-dev
+          - apt-get update && apt-get install -y libyaml-dev libssl-dev
           - ruby -v
           - bundle install
           - bundle exec rake ci

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## [Unreleased]
 
+## [0.17.0] - 2026-08-29
+
+- Reserve BPF-routed connections before accept
+- Skip unnecessary HTTP/1.1 response work
+- Assemble HTTP/2 response headers in C
+- Emit HTTP/1.1 response headers and chunked bodies in C
+- Decode chunked request bodies in C
+
 ## [0.16.1] - 2026-08-23
 
 - Drop the stale `Ractors=NUM` option from the Rackup handler

data/README.md

@@ -37,7 +37,7 @@ run proc { |_env| [200, { "content-type" => "text/plain" }, ["Hello, World!"]] }
 ```
 > bundle exec raptor -w 10 -t 3 hello_world.ru
 [Raptor 83654|Main|Main] Cluster initializing:
-[Raptor 83654|Main|Main] ├─ Version: 0.16.1
+[Raptor 83654|Main|Main] ├─ Version: 0.17.0
 [Raptor 83654|Main|Main] ├─ Ruby Version: ruby 4.0.6 (2026-07-14 revision 03b6d3f889) +YJIT +PRISM [arm64-darwin23]
 [Raptor 83654|Main|Main] ├─ Environment: development
 [Raptor 83654|Main|Main] ├─ Master PID: 83654
@@ -201,7 +201,7 @@ Worker 1 (phase 0): pid=91351, requests=1199, busy=1/3, backlog=0, booted, last_
 
 ## (Micro) Benchmarks
 
-Raptor 0.16.1 vs Puma 8.0.2 vs Falcon 0.57.0 across two workload profiles. **IO-bound** is a GET endpoint that
+Raptor 0.17.0 vs Puma 8.0.2 vs Falcon 0.57.0 across two workload profiles. **IO-bound** is a GET endpoint that
 interleaves 5-10 short sleeps (total 2.5-15ms) with small CPU work, simulating a read path that makes several DB or
 cache calls. **CPU-bound** is a POST endpoint that accepts a small JSON body, interleaves 3-5 chunks of JSON item
 building (total 450-1500 items) with sub-100µs sleeps, and returns the built array, simulating a write path that does
@@ -210,16 +210,16 @@ most of its work in Ruby with a few near-zero-cost cache hits.
 Each cell reports the median throughput and median p95 latency independently across 5 runs, so the two numbers in a row
 may come from different runs. Every run starts a fresh server process so the samples are independent of each other;
 state accumulated in a previous run cannot bias the next. Across the whole table, the widest spread
-((max - min) / 2 / median) between runs of a single cell was ±24.8% for throughput and ±40.3% for p95.
+((max - min) / 2 / median) between runs of a single cell was ±22.4% for throughput and ±37.4% for p95.
 
 | Protocol              | Workload | Raptor req/s | Raptor p95 | Puma req/s  | Puma p95  | vs Puma req/s | vs Puma p95  | Falcon req/s | Falcon p95 | vs Falcon req/s | vs Falcon p95 |
 | --------------------- | -------- | ------------ | ---------- | ----------- | --------- | ------------- | ------------ | ------------ | ---------- | --------------- | ------------- |
-| HTTP/1.1              | IO       | 3.21k req/s  | 63.20 ms   | 1.48k req/s | 131.00 ms | 117.7% higher | 51.8% lower  | 12.27k req/s | 14.00 ms   | 73.8% lower     | 351.4% higher |
-| HTTP/1.1              | CPU      | 8.29k req/s  | 33.30 ms   | 8.56k req/s | 21.20 ms  | 3.2% lower    | 57.1% higher | 6.62k req/s  | 27.00 ms   | 25.2% higher    | 23.3% higher  |
-| HTTP/1.1 (keep-alive) | IO       | 2.43k req/s  | 54.40 ms   | 1.44k req/s | 110.20 ms | 68.7% higher  | 50.6% lower  | 6.28k req/s  | 27.90 ms   | 61.3% lower     | 95.0% higher  |
-| HTTP/1.1 (keep-alive) | CPU      | 8.40k req/s  | 18.80 ms   | 8.49k req/s | 21.90 ms  | 1.1% lower    | 14.2% lower  | 7.09k req/s  | 31.50 ms   | 18.5% higher    | 40.3% lower   |
-| HTTP/2                | IO       | 0.97k req/s  | 197.97 ms  | N/A         | N/A       | -             | -            | 6.59k req/s  | 27.21 ms   | 85.2% lower     | 627.6% higher |
-| HTTP/2                | CPU      | 6.61k req/s  | 31.98 ms   | N/A         | N/A       | -             | -            | 8.09k req/s  | 45.04 ms   | 18.3% lower     | 29.0% lower   |
+| HTTP/1.1              | IO       | 3.35k req/s  | 59.60 ms   | 1.51k req/s | 126.70 ms | 121.9% higher | 53.0% lower  | 12.19k req/s | 14.10 ms   | 72.6% lower     | 322.7% higher |
+| HTTP/1.1              | CPU      | 8.31k req/s  | 25.00 ms   | 8.63k req/s | 21.10 ms  | 3.7% lower    | 18.5% higher | 6.57k req/s  | 27.40 ms   | 26.4% higher    | 8.8% lower    |
+| HTTP/1.1 (keep-alive) | IO       | 3.22k req/s  | 46.90 ms   | 1.47k req/s | 113.80 ms | 119.9% higher | 58.8% lower  | 6.23k req/s  | 28.20 ms   | 48.2% lower     | 66.3% higher  |
+| HTTP/1.1 (keep-alive) | CPU      | 8.30k req/s  | 23.30 ms   | 8.41k req/s | 22.10 ms  | 1.3% lower    | 5.4% higher  | 6.95k req/s  | 32.30 ms   | 19.5% higher    | 27.9% lower   |
+| HTTP/2                | IO       | 0.98k req/s  | 196.28 ms  | N/A         | N/A       | -             | -            | 6.55k req/s  | 27.71 ms   | 85.1% lower     | 608.4% higher |
+| HTTP/2                | CPU      | 6.23k req/s  | 33.11 ms   | N/A         | N/A       | -             | -            | 6.92k req/s  | 42.94 ms   | 10.0% lower     | 22.9% lower   |
 
 > ruby 4.0.6 (2026-07-14 revision 03b6d3f889) +YJIT +PRISM [aarch64-linux]
 > 10 worker processes; Raptor and Puma run 3 threads per worker, Falcon runs unbounded fibers per worker;

data/docs/brisrails-talk.md

@@ -37,7 +37,7 @@ _[luma.com/t3l24s8h](https://luma.com/t3l24s8h)_
 - <big>I built a Ruby web server over the last few months</big>
 - <big>It's called Raptor</big>
 - <big>It runs Rack apps, like Puma and Falcon do</big>
-- <big>It's built around Ruby 4's Ractors</big>
+- <big>It's built around a Ractor-parallel HTTP parser</big>
 - <big>It's fast enough that the numbers are interesting</big>
 - <big>It's not production-ready. Nobody's Rails app should be behind it yet.</big>
 

data/docs/raptor-vs-puma.md

@@ -1,6 +1,6 @@
 # Raptor vs Puma: A Design Comparison
 
-Raptor is a Ruby web server designed around Ruby 4's Ractors. On CPU-bound HTTP/1.1 it holds a real edge over the latest Puma release on the same hardware regardless of keep-alive; on IO-heavy work fibers still win, and Falcon is the server to compare to there rather than Raptor or Puma. Raptor also speaks HTTP/2 natively, which Puma does not. This document is a systems-design walkthrough of how it manages both.
+Raptor is a Ruby web server designed around a Ractor-parallel HTTP parser. On CPU-bound HTTP/1.1 it holds a real edge over the latest Puma release on the same hardware regardless of keep-alive; on IO-heavy work fibers still win, and Falcon is the server to compare to there rather than Raptor or Puma. Raptor also speaks HTTP/2 natively, which Puma does not. This document is a systems-design walkthrough of how it manages both.
 
 ## Why this document exists
 

data/ext/raptor_bpf/reuseport_select.bpf.c

@@ -2,7 +2,6 @@
 #include <bpf/bpf_helpers.h>
 
 #define MAX_WORKERS 64
-#define LOAD_TIE_TOLERANCE 1
 
 // Per-worker listening sockets, keyed by worker index.
 struct {
@@ -20,14 +19,12 @@ struct {
   __uint(max_entries, MAX_WORKERS + 1);
 } loads SEC(".maps");
 
-// Routes each incoming connection to the least-loaded worker. When the
-// spread between the busiest and idlest worker is within
-// `LOAD_TIE_TOLERANCE`, all workers are treated as tied and the connection
-// is placed by 4-tuple hash so bursts of accepts spread across workers
-// instead of clustering on whichever worker most recently reported the
-// lowest load.
+// Uses the power-of-two-choices strategy and reserves the selected worker's
+// slot before returning. Sampling two hash-selected workers avoids
+// concentrating variable-cost requests, while the reservation prevents a
+// burst from repeatedly selecting the same reported load.
 SEC("sk_reuseport")
-int select_least_loaded(struct sk_reuseport_md *ctx) {
+int select_less_loaded(struct sk_reuseport_md *ctx) {
   __u32 count_key = 0;
   __u32 *count_ptr = bpf_map_lookup_elem(&loads, &count_key);
   if (!count_ptr || *count_ptr == 0) {
@@ -38,29 +35,23 @@ int select_least_loaded(struct sk_reuseport_md *ctx) {
     num_workers = MAX_WORKERS;
   }
 
-  __u32 min_load = ~0u;
-  __u32 max_load = 0;
-  __u32 min_idx = 0;
-
-  for (__u32 worker_idx = 0; worker_idx < MAX_WORKERS; worker_idx++) {
-    if (worker_idx >= num_workers) {
-      break;
-    }
-    __u32 worker_key = worker_idx + 1;
-    __u32 *load_ptr = bpf_map_lookup_elem(&loads, &worker_key);
-    if (!load_ptr) {
-      continue;
-    }
-    if (*load_ptr < min_load) {
-      min_load = *load_ptr;
-      min_idx = worker_idx;
-    }
-    if (*load_ptr > max_load) {
-      max_load = *load_ptr;
+  __u32 chosen_idx = ctx->hash % num_workers;
+  __u32 chosen_key = chosen_idx + 1;
+  __u32 *chosen_load = bpf_map_lookup_elem(&loads, &chosen_key);
+  if (num_workers > 1) {
+    __u32 alternate_idx = (chosen_idx + 1 + ((ctx->hash >> 16) % (num_workers - 1))) % num_workers;
+    __u32 alternate_key = alternate_idx + 1;
+    __u32 *alternate_load = bpf_map_lookup_elem(&loads, &alternate_key);
+    if (chosen_load && alternate_load && *alternate_load < *chosen_load) {
+      chosen_idx = alternate_idx;
+      chosen_load = alternate_load;
     }
   }
 
-  __u32 chosen_idx = (max_load - min_load <= LOAD_TIE_TOLERANCE) ? (ctx->hash % num_workers) : min_idx;
+  if (chosen_load) {
+    __sync_fetch_and_add(chosen_load, 1);
+  }
+
   bpf_sk_select_reuseport(ctx, &socks, &chosen_idx, 0);
   return SK_PASS;
 }

data/ext/raptor_http/raptor_http.c

@@ -37,6 +37,8 @@ typedef struct raptor_parser {
 #define FLAG_HAS_BODY 0x2
 #define FLAG_FINISHED 0x4
 
+#define MAX_CHUNK_OVERHEAD (16 * 1024)
+
 static VALUE eHttpParserError;
 static VALUE global_request_method;
 static VALUE global_request_uri;
@@ -44,6 +46,10 @@ static VALUE global_query_string;
 static VALUE global_server_protocol;
 static VALUE global_request_path;
 static VALUE global_fragment;
+static ID id_complete;
+static ID id_incomplete;
+static ID id_malformed;
+static ID id_too_large;
 
 struct common_field {
   const char *name;
@@ -1316,6 +1322,200 @@ static VALUE parser_body(VALUE self) {
   return parser->body;
 }
 
+static const char *find_crlf(const char *buf, size_t len) {
+  if (len < 2) return NULL;
+  const char *end = buf + len - 1;
+  for (const char *p = buf; p < end; p++) {
+    if (*p == '\r' && *(p + 1) == '\n') return p;
+  }
+  return NULL;
+}
+
+static VALUE parser_decode_chunked(int argc, VALUE *argv, VALUE self) {
+  (void)self;
+  VALUE buffer, max_size;
+  rb_scan_args(argc, argv, "11", &buffer, &max_size);
+  Check_Type(buffer, T_STRING);
+
+  const char *buf = RSTRING_PTR(buffer);
+  size_t len = (size_t)RSTRING_LEN(buffer);
+  size_t offset = 0;
+  size_t overhead = 0;
+  int has_max = !NIL_P(max_size);
+  size_t max_bytes = has_max ? NUM2SIZET(max_size) : 0;
+
+  VALUE decoded = rb_str_buf_new((long)len);
+
+  while (offset < len) {
+    const char *crlf = find_crlf(buf + offset, len - offset);
+    if (!crlf) return rb_ary_new_from_args(2, decoded, ID2SYM(id_incomplete));
+
+    size_t line_len = (size_t)(crlf - (buf + offset));
+    size_t size_len = line_len;
+    for (size_t i = 0; i < line_len; i++) {
+      if (buf[offset + i] == ';') { size_len = i; break; }
+    }
+    if (size_len == 0) return rb_ary_new_from_args(2, decoded, ID2SYM(id_malformed));
+
+    uint64_t chunk_size = 0;
+    for (size_t i = 0; i < size_len; i++) {
+      char c = buf[offset + i];
+      uint64_t digit;
+      if (c >= '0' && c <= '9') digit = (uint64_t)(c - '0');
+      else if (c >= 'a' && c <= 'f') digit = (uint64_t)(c - 'a' + 10);
+      else if (c >= 'A' && c <= 'F') digit = (uint64_t)(c - 'A' + 10);
+      else return rb_ary_new_from_args(2, decoded, ID2SYM(id_malformed));
+      if (chunk_size > (UINT64_MAX >> 4)) return rb_ary_new_from_args(2, decoded, ID2SYM(id_malformed));
+      chunk_size = (chunk_size << 4) | digit;
+    }
+    if (chunk_size > (uint64_t)(SIZE_MAX / 2)) return rb_ary_new_from_args(2, decoded, ID2SYM(id_malformed));
+
+    size_t crlf_offset = offset + line_len;
+
+    if (chunk_size == 0) {
+      size_t trailer_offset = crlf_offset + 2;
+      while (1) {
+        if (trailer_offset >= len) return rb_ary_new_from_args(2, decoded, ID2SYM(id_incomplete));
+        const char *tcrlf = find_crlf(buf + trailer_offset, len - trailer_offset);
+        if (!tcrlf) return rb_ary_new_from_args(2, decoded, ID2SYM(id_incomplete));
+        if (tcrlf == buf + trailer_offset) return rb_ary_new_from_args(2, decoded, ID2SYM(id_complete));
+        trailer_offset = (size_t)(tcrlf - buf) + 2;
+      }
+    }
+
+    size_t decoded_len = (size_t)RSTRING_LEN(decoded);
+    if (has_max && (decoded_len + (size_t)chunk_size) > max_bytes) {
+      return rb_ary_new_from_args(2, decoded, ID2SYM(id_too_large));
+    }
+
+    overhead += line_len + 4;
+    if (overhead > (decoded_len + (size_t)chunk_size + MAX_CHUNK_OVERHEAD)) {
+      return rb_ary_new_from_args(2, decoded, ID2SYM(id_malformed));
+    }
+
+    size_t data_offset = crlf_offset + 2;
+    size_t available = len > data_offset ? len - data_offset : 0;
+    size_t bytes_to_copy = (size_t)chunk_size < available ? (size_t)chunk_size : available;
+    rb_str_cat(decoded, buf + data_offset, (long)bytes_to_copy);
+
+    offset = data_offset + (size_t)chunk_size + 2;
+  }
+
+  return rb_ary_new_from_args(2, decoded, ID2SYM(id_incomplete));
+}
+
+static uint8_t illegal_header_key_bitmap[32];
+static uint8_t illegal_header_value_bitmap[32];
+
+static void bitmap_set(uint8_t *bitmap, unsigned char byte) {
+  bitmap[byte >> 3] |= (uint8_t)(1u << (byte & 7));
+}
+
+static int contains_illegal_byte(const uint8_t *bitmap, const char *str, size_t len) {
+  for (size_t i = 0; i < len; i++) {
+    unsigned char byte = (unsigned char)str[i];
+    if ((bitmap[byte >> 3] >> (byte & 7)) & 1) return 1;
+  }
+  return 0;
+}
+
+static VALUE parser_illegal_header_key_p(VALUE self, VALUE key) {
+  (void)self;
+  Check_Type(key, T_STRING);
+  return contains_illegal_byte(illegal_header_key_bitmap, RSTRING_PTR(key), (size_t)RSTRING_LEN(key)) ? Qtrue : Qfalse;
+}
+
+static VALUE parser_illegal_header_value_p(VALUE self, VALUE value) {
+  (void)self;
+  Check_Type(value, T_STRING);
+  return contains_illegal_byte(illegal_header_value_bitmap, RSTRING_PTR(value), (size_t)RSTRING_LEN(value)) ? Qtrue : Qfalse;
+}
+
+static void emit_header_line(VALUE buffer, const char *name, long name_len,
+                             const char *value, long value_len) {
+  if (value_len == 0) return;
+  if (contains_illegal_byte(illegal_header_value_bitmap, value, (size_t)value_len)) return;
+  rb_str_cat(buffer, name, name_len);
+  rb_str_cat(buffer, ": ", 2);
+  rb_str_cat(buffer, value, value_len);
+  rb_str_cat(buffer, "\r\n", 2);
+}
+
+static void emit_header(VALUE buffer, const char *name, long name_len, VALUE value) {
+  VALUE str = RB_TYPE_P(value, T_STRING) ? value : rb_funcall(value, rb_intern("to_s"), 0);
+  const char *ptr = RSTRING_PTR(str);
+  long len = RSTRING_LEN(str);
+  if (len == 0) return;
+
+  if (!memchr(ptr, '\n', (size_t)len)) {
+    emit_header_line(buffer, name, name_len, ptr, len);
+    return;
+  }
+
+  long line_start = 0;
+  for (long i = 0; i < len; i++) {
+    if (ptr[i] == '\n') {
+      emit_header_line(buffer, name, name_len, ptr + line_start, i - line_start);
+      line_start = i + 1;
+    }
+  }
+  if (line_start < len) {
+    emit_header_line(buffer, name, name_len, ptr + line_start, len - line_start);
+  }
+}
+
+static int format_header_iter(VALUE key, VALUE value, VALUE data) {
+  VALUE buffer = (VALUE)data;
+  if (!RB_TYPE_P(key, T_STRING)) return ST_CONTINUE;
+  const char *name = RSTRING_PTR(key);
+  long name_len = RSTRING_LEN(key);
+  if (contains_illegal_byte(illegal_header_key_bitmap, name, (size_t)name_len)) return ST_CONTINUE;
+
+  if (RB_TYPE_P(value, T_ARRAY)) {
+    long entries = RARRAY_LEN(value);
+    for (long i = 0; i < entries; i++) {
+      emit_header(buffer, name, name_len, RARRAY_AREF(value, i));
+    }
+  } else {
+    emit_header(buffer, name, name_len, value);
+  }
+  return ST_CONTINUE;
+}
+
+static VALUE parser_format_headers(VALUE self, VALUE buffer, VALUE headers) {
+  (void)self;
+  Check_Type(buffer, T_STRING);
+  Check_Type(headers, T_HASH);
+  rb_hash_foreach(headers, format_header_iter, buffer);
+  return buffer;
+}
+
+static VALUE parser_chunked_encode(VALUE self, VALUE buffer, VALUE chunk) {
+  (void)self;
+  Check_Type(buffer, T_STRING);
+  Check_Type(chunk, T_STRING);
+  long chunk_len = RSTRING_LEN(chunk);
+  if (chunk_len == 0) return buffer;
+
+  char hex_buf[17];
+  int hex_len = snprintf(hex_buf, sizeof(hex_buf), "%lx", (unsigned long)chunk_len);
+  rb_str_cat(buffer, hex_buf, hex_len);
+  rb_str_cat(buffer, "\r\n", 2);
+  rb_str_cat(buffer, RSTRING_PTR(chunk), chunk_len);
+  rb_str_cat(buffer, "\r\n", 2);
+  return buffer;
+}
+
+static void init_illegal_header_bitmaps(void) {
+  for (int byte = 0x00; byte <= 0x20; byte++) bitmap_set(illegal_header_key_bitmap, (unsigned char)byte);
+  const char *key_specials = "()<>@,;:\\\"/[]?={}";
+  for (const char *p = key_specials; *p; p++) bitmap_set(illegal_header_key_bitmap, (unsigned char)*p);
+  bitmap_set(illegal_header_key_bitmap, 0x7F);
+
+  for (int byte = 0x00; byte <= 0x08; byte++) bitmap_set(illegal_header_value_bitmap, (unsigned char)byte);
+  for (int byte = 0x0A; byte <= 0x1F; byte++) bitmap_set(illegal_header_value_bitmap, (unsigned char)byte);
+}
+
 RUBY_FUNC_EXPORTED void Init_raptor_http(void) {
   rb_ext_ractor_safe(true);
 
@@ -1337,6 +1537,13 @@ RUBY_FUNC_EXPORTED void Init_raptor_http(void) {
   global_request_path = rb_str_new2("PATH_INFO");
   global_fragment = rb_str_new2("FRAGMENT");
 
+  id_complete = rb_intern("complete");
+  id_incomplete = rb_intern("incomplete");
+  id_malformed = rb_intern("malformed");
+  id_too_large = rb_intern("too_large");
+
+  init_illegal_header_bitmaps();
+
   for (size_t i = 0; i < NUM_COMMON_FIELDS; i++) {
     common_fields[i].interned = rb_enc_interned_str(common_fields[i].name, common_fields[i].len, rb_utf8_encoding());
     rb_global_variable(&common_fields[i].interned);
@@ -1351,4 +1558,10 @@ RUBY_FUNC_EXPORTED void Init_raptor_http(void) {
   rb_define_method(cHttpParser, "nread", parser_nread, 0);
   rb_define_method(cHttpParser, "reset", parser_reset, 0);
   rb_define_method(cHttpParser, "body", parser_body, 0);
+  rb_define_singleton_method(cHttpParser, "decode_chunked", parser_decode_chunked, -1);
+  rb_define_singleton_method(cHttpParser, "illegal_header_key?", parser_illegal_header_key_p, 1);
+  rb_define_singleton_method(cHttpParser, "illegal_header_value?", parser_illegal_header_value_p, 1);
+  rb_define_singleton_method(cHttpParser, "format_headers", parser_format_headers, 2);
+  rb_define_singleton_method(cHttpParser, "chunked_encode", parser_chunked_encode, 2);
+  rb_define_const(cHttpParser, "MAX_CHUNK_OVERHEAD", INT2FIX(MAX_CHUNK_OVERHEAD));
 }

data/ext/raptor_http2/raptor_http2.c

@@ -599,6 +599,65 @@ static VALUE h2_encode_headers(VALUE self, VALUE headers) {
   return hpack_encode_header_block(headers);
 }
 
+static const char *const HOP_BY_HOP_HEADERS[] = {
+  "connection", "transfer-encoding", "keep-alive", "upgrade", "proxy-connection"
+};
+#define NUM_HOP_BY_HOP_HEADERS 5
+
+static int is_hop_by_hop(const char *name, long name_len) {
+  for (size_t i = 0; i < NUM_HOP_BY_HOP_HEADERS; i++) {
+    size_t hbh_len = strlen(HOP_BY_HOP_HEADERS[i]);
+    if ((long)hbh_len == name_len && memcmp(name, HOP_BY_HOP_HEADERS[i], hbh_len) == 0) return 1;
+  }
+  return 0;
+}
+
+static VALUE ascii_lowercase_str(VALUE str) {
+  long len = RSTRING_LEN(str);
+  VALUE lower = rb_str_new(RSTRING_PTR(str), len);
+  char *ptr = RSTRING_PTR(lower);
+  for (long i = 0; i < len; i++) {
+    if (ptr[i] >= 'A' && ptr[i] <= 'Z') ptr[i] = (char)(ptr[i] | 0x20);
+  }
+  return lower;
+}
+
+static int response_headers_iter(VALUE key, VALUE value, VALUE data) {
+  VALUE pairs = data;
+  if (!RB_TYPE_P(key, T_STRING)) return ST_CONTINUE;
+
+  VALUE lowered = ascii_lowercase_str(key);
+  const char *lname = RSTRING_PTR(lowered);
+  long lname_len = RSTRING_LEN(lowered);
+
+  if (lname_len >= 5 && memcmp(lname, "rack.", 5) == 0) return ST_CONTINUE;
+  if (is_hop_by_hop(lname, lname_len)) return ST_CONTINUE;
+
+  if (RB_TYPE_P(value, T_ARRAY)) {
+    long entries = RARRAY_LEN(value);
+    for (long i = 0; i < entries; i++) {
+      VALUE entry = RARRAY_AREF(value, i);
+      VALUE str = RB_TYPE_P(entry, T_STRING) ? entry : rb_obj_as_string(entry);
+      rb_ary_push(pairs, rb_ary_new_from_args(2, lowered, str));
+    }
+  } else {
+    VALUE str = RB_TYPE_P(value, T_STRING) ? value : rb_obj_as_string(value);
+    rb_ary_push(pairs, rb_ary_new_from_args(2, lowered, str));
+  }
+  return ST_CONTINUE;
+}
+
+static VALUE h2_encode_response_headers(VALUE self, VALUE status, VALUE headers) {
+  (void)self;
+  Check_Type(headers, T_HASH);
+
+  VALUE pairs = rb_ary_new();
+  rb_ary_push(pairs, rb_ary_new_from_args(2, rb_str_new_lit(":status"), rb_obj_as_string(status)));
+  rb_hash_foreach(headers, response_headers_iter, pairs);
+
+  return hpack_encode_header_block(pairs);
+}
+
 static VALUE h2_parse_frame(VALUE self, VALUE buffer) {
   (void)self;
   Check_Type(buffer, T_STRING);
@@ -765,6 +824,7 @@ RUBY_FUNC_EXPORTED void Init_raptor_http2(void) {
   rb_define_method(cHttp2Parser, "parse_frame", h2_parse_frame, 1);
   rb_define_method(cHttp2Parser, "parse_headers", h2_parse_headers, 2);
   rb_define_method(cHttp2Parser, "encode_headers", h2_encode_headers, 1);
+  rb_define_method(cHttp2Parser, "encode_response_headers", h2_encode_response_headers, 2);
   rb_define_method(cHttp2Parser, "parse_settings", h2_parse_settings, 1);
   rb_define_method(cHttp2Parser, "build_settings", h2_build_settings, 1);
   rb_define_method(cHttp2Parser, "build_frame", h2_build_frame, 4);

data/lib/raptor/http1.rb

@@ -21,7 +21,6 @@ module Raptor
     BODY_BUFFER_THRESHOLD = 256 * 1024
     CHUNKED_WRITE_THRESHOLD = 512 * 1024
     FILE_CHUNK_SIZE = 64 * 1024
-    MAX_CHUNK_OVERHEAD = 16 * 1024
     READ_BUFFER_SIZE = 64 * 1024
     RESPONSE_BUFFER_CAPACITY = 4 * 1024
     KEEPALIVE_READ_TIMEOUT = 0.001
@@ -38,7 +37,6 @@ module Raptor
       h[status] = "HTTP/1.1 #{status}#{reason ? " #{reason}" : ""}\r\n".freeze
     end
 
-    STATUS_WITH_NO_ENTITY_BODY = [204, 304, *100..199].freeze
     CONTINUE_RESPONSE = "HTTP/1.1 100 Continue\r\n\r\n"
     BAD_REQUEST_RESPONSE = "HTTP/1.1 400 Bad Request\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
     CONTENT_TOO_LARGE_RESPONSE = "HTTP/1.1 413 Content Too Large\r\nContent-Length: 0\r\nConnection: close\r\n\r\n"
@@ -48,6 +46,7 @@ module Raptor
     CONNECTION_KEEPALIVE = "keep-alive"
     EXPECT_100_CONTINUE = "100-continue"
     TRANSFER_ENCODING_CHUNKED = "chunked"
+    CHUNKED_TERMINATOR = "0\r\n\r\n"
 
     HTTP_CONNECTION = "HTTP_CONNECTION"
     HTTP_EXPECT = "HTTP_EXPECT"
@@ -56,10 +55,6 @@ module Raptor
     RACK_HIJACKED = "rack.hijacked"
     RACK_HIJACK_IO = "rack.hijack_io"
 
-    ILLEGAL_HEADER_KEY_REGEX = /[\x00-\x20\(\)<>@,;:\\"\/\[\]\?=\{\}\x7F]/
-    ILLEGAL_HEADER_VALUE_REGEX = /[\x00-\x08\x0A-\x1F]/
-    CHUNK_SIZE_REGEX = /\A[0-9A-Fa-f]+\z/
-
     # Returns true when an HTTP/1.1 request lacks a valid `Host` header per
     # RFC 9112 section 3.2, where a valid value is a non-empty single-value
     # line.
@@ -102,59 +97,6 @@ module Raptor
       false
     end
 
-    # Decodes a chunked transfer-encoded body buffer.
-    #
-    # Returns the decoded bytes and a state symbol: `:complete` when the
-    # terminating zero-length chunk and trailer section were fully consumed,
-    # `:too_large` when the decoded size would exceed `max_size`, `:malformed`
-    # when a chunk-size line is not valid hex or chunk framing overhead exceeds
-    # `MAX_CHUNK_OVERHEAD`, or `:incomplete` otherwise.
-    #
-    # @param buffer [String] the raw body buffer to decode
-    # @param max_size [Integer, nil] maximum decoded body size, or nil for unlimited
-    # @return [Array(String, Symbol)] decoded body and completion state
-    #
-    # @rbs (String buffer, ?Integer? max_size) -> [String, Symbol]
-    def self.decode_chunked(buffer, max_size = nil)
-      decoded = String.new
-      offset = 0
-      overhead = 0
-
-      while offset < buffer.bytesize
-        crlf = buffer.index("\r\n", offset)
-        return [decoded, :incomplete] unless crlf
-
-        size_line = buffer.byteslice(offset, crlf - offset)
-        semicolon = size_line.index(";")
-        size_part = semicolon ? size_line.byteslice(0, semicolon) : size_line
-        return [decoded, :malformed] unless size_part.match?(CHUNK_SIZE_REGEX)
-
-        chunk_size = size_part.to_i(16)
-
-        if chunk_size.zero?
-          trailer_offset = crlf + 2
-          loop do
-            trailer_crlf = buffer.index("\r\n", trailer_offset)
-            return [decoded, :incomplete] unless trailer_crlf
-            return [decoded, :complete] if trailer_crlf == trailer_offset
-
-            trailer_offset = trailer_crlf + 2
-          end
-        end
-
-        return [decoded, :too_large] if max_size && (decoded.bytesize + chunk_size) > max_size
-
-        overhead += (crlf - offset) + 4
-        return [decoded, :malformed] if overhead > (decoded.bytesize + chunk_size + MAX_CHUNK_OVERHEAD)
-
-        offset = crlf + 2
-        decoded << buffer.byteslice(offset, chunk_size)
-        offset += chunk_size + 2
-      end
-
-      [decoded, :incomplete]
-    end
-
     # Advances an HTTP/1.x request parse from the state hash's buffered
     # bytes. A complete well-formed request returns with `:complete` set
     # plus populated `:env` and `:body`; malformed or oversized input flips
@@ -191,7 +133,7 @@ module Raptor
           if max_body_size && parser.content_length > max_body_size
             data.merge(env: env, body: nil, parse_data: parse_data, complete: true, too_large: true)
           elsif parser.chunked?
-            decoded_body, chunked_state = decode_chunked(body_buffer, max_body_size)
+            decoded_body, chunked_state = HttpParser.decode_chunked(body_buffer, max_body_size)
 
             case chunked_state
             when :complete
@@ -479,7 +421,7 @@ module Raptor
       if parser.chunked?
         return :incomplete unless decode_chunked
 
-        body, chunked_state = Http1.decode_chunked(body, @max_body_size)
+        body, chunked_state = HttpParser.decode_chunked(body, @max_body_size)
         case chunked_state
         when :complete
           env.delete(HTTP_TRANSFER_ENCODING)
@@ -581,7 +523,7 @@ module Raptor
           hijacked = headers.is_a?(Hash) && !!headers[Rack::RACK_HIJACK]
           streaming = body.respond_to?(:call) && !body.respond_to?(:each)
           keep_alive = (hijacked || streaming) ? false : keep_alive?(rack_env, request_count)
-          response_size = response_size(headers, body) unless hijacked
+          response_size = response_size(headers, body) if @access_log_io && !hijacked
           response_started = true
           write_response(socket, rack_env, status, headers, body, keep_alive: keep_alive)
         end
@@ -919,11 +861,11 @@ module Raptor
 
       response = +"#{HTTP_11} 103 Early Hints\r\n"
       hints.each do |key, value|
-        next if illegal_header_key?(key)
+        next if HttpParser.illegal_header_key?(key)
 
         values = value.is_a?(Array) ? value : [value]
         values.each do |hint_value|
-          next if illegal_header_value?(hint_value.to_s)
+          next if HttpParser.illegal_header_value?(hint_value.to_s)
 
           response << "#{key.downcase}: #{hint_value}\r\n"
         end
@@ -948,27 +890,29 @@ module Raptor
       validate_status(status)
       response_hijack = headers.is_a?(Hash) ? headers.delete(Rack::RACK_HIJACK) : nil
       headers = normalize_headers(headers)
-      validate_headers(headers, status)
+      no_entity_body = (status >= 100 && status < 200) || status == 204 || status == 304
+      validate_headers(headers, status, no_entity_body)
 
       headers["connection"] = keep_alive ? CONNECTION_KEEPALIVE : CONNECTION_CLOSE
 
       http_version = env[Rack::SERVER_PROTOCOL] == HTTP_11 ? HTTP_11 : HTTP_10
-      no_body = env[Rack::REQUEST_METHOD] == "HEAD" || STATUS_WITH_NO_ENTITY_BODY.include?(status)
+      no_body = env[Rack::REQUEST_METHOD] == "HEAD" || no_entity_body
 
       response = build_status_line(http_version, status)
 
-      cork_socket(socket)
+      corked = !keep_alive
+      cork_socket(socket) if corked
 
       if response_hijack
         write_hijacked_response(socket, response, headers, response_hijack)
       elsif no_body
-        write_no_body_response(socket, response, headers, status)
+        write_no_body_response(socket, response, headers, no_entity_body)
       else
         write_full_response(socket, response, headers, body, http_version)
       end
     ensure
       body.close if body.respond_to?(:close)
-      uncork_socket(socket)
+      uncork_socket(socket) if corked
       socket.flush rescue nil
     end
 
@@ -1001,7 +945,7 @@ module Raptor
       headers.each do |key, value|
         raise TypeError, "header keys must be Strings" unless key.is_a?(String)
 
-        next if illegal_header_key?(key)
+        next if HttpParser.illegal_header_key?(key)
 
         normalized_key = key.match?(/[A-Z]/) ? key.downcase : key
         next if normalized_key.start_with?(RACK_HEADER_PREFIX)
@@ -1017,12 +961,13 @@ module Raptor
     #
     # @param headers [Hash] normalized response headers
     # @param status [Integer] HTTP status code
+    # @param no_entity_body [Boolean] whether the status forbids an entity body
     # @return [void]
     # @raise [ArgumentError] if a forbidden header is present for the status
     #
-    # @rbs (Hash[String, String | Array[String]] headers, Integer status) -> void
-    def validate_headers(headers, status)
-      if STATUS_WITH_NO_ENTITY_BODY.include?(status)
+    # @rbs (Hash[String, String | Array[String]] headers, Integer status, bool no_entity_body) -> void
+    def validate_headers(headers, status, no_entity_body)
+      if no_entity_body
         raise ArgumentError, "content-type must not be present for status #{status}" if headers.key?(Rack::CONTENT_TYPE)
 
         raise ArgumentError, "content-length must not be present for status #{status}" if headers.key?(Rack::CONTENT_LENGTH)
@@ -1055,7 +1000,7 @@ module Raptor
     #
     # @rbs (TCPSocket socket, String response, Hash[String, String | Array[String]] headers, ^(TCPSocket) -> void response_hijack) -> void
     def write_hijacked_response(socket, response, headers, response_hijack)
-      format_headers(response, headers)
+      HttpParser.format_headers(response, headers)
       response << "\r\n"
       socket_write(socket, response)
       uncork_socket(socket)
@@ -1069,16 +1014,16 @@ module Raptor
     # @param socket [TCPSocket] the client socket
     # @param response [String] the status line accumulated so far
     # @param headers [Hash] normalized response headers
-    # @param status [Integer] HTTP status code
+    # @param no_entity_body [Boolean] whether the response status forbids an entity body
     # @return [void]
     #
-    # @rbs (TCPSocket socket, String response, Hash[String, String | Array[String]] headers, Integer status) -> void
-    def write_no_body_response(socket, response, headers, status)
-      unless STATUS_WITH_NO_ENTITY_BODY.include?(status)
+    # @rbs (TCPSocket socket, String response, Hash[String, String | Array[String]] headers, bool no_entity_body) -> void
+    def write_no_body_response(socket, response, headers, no_entity_body)
+      unless no_entity_body
         headers[Rack::CONTENT_LENGTH] = "0" unless headers.key?(Rack::CONTENT_LENGTH) || headers.key?(Rack::TRANSFER_ENCODING)
       end
 
-      format_headers(response, headers)
+      HttpParser.format_headers(response, headers)
       response << "\r\n"
       socket_write(socket, response)
     end
@@ -1097,7 +1042,7 @@ module Raptor
     # @rbs (TCPSocket socket, String response, Hash[String, String | Array[String]] headers, untyped body, String http_version) -> void
     def write_full_response(socket, response, headers, body, http_version)
       if body.respond_to?(:call)
-        format_headers(response, headers)
+        HttpParser.format_headers(response, headers)
         response << "\r\n"
         socket_write(socket, response)
         uncork_socket(socket)
@@ -1123,7 +1068,7 @@ module Raptor
         headers[Rack::TRANSFER_ENCODING] = TRANSFER_ENCODING_CHUNKED
       end
 
-      format_headers(response, headers)
+      HttpParser.format_headers(response, headers)
       response << "\r\n"
 
       if body.respond_to?(:to_path) && (path = body.to_path) && File.readable?(path)
@@ -1172,13 +1117,13 @@ module Raptor
         if use_chunked
           buffer = response
           while (chunk = file.read(FILE_CHUNK_SIZE))
-            buffer << chunk.bytesize.to_s(16) << "\r\n" << chunk << "\r\n"
+            HttpParser.chunked_encode(buffer, chunk)
             if buffer.bytesize >= CHUNKED_WRITE_THRESHOLD
               socket_write(socket, buffer)
               buffer = +""
             end
           end
-          buffer << "0\r\n\r\n"
+          buffer << CHUNKED_TERMINATOR
           socket_write(socket, buffer)
         elsif content_length && content_length < BODY_BUFFER_THRESHOLD
           response << file.read(content_length)
@@ -1221,7 +1166,8 @@ module Raptor
       raise TypeError, "body must yield String values" unless chunk.is_a?(String)
 
       if use_chunked
-        response << chunk.bytesize.to_s(16) << "\r\n" << chunk << "\r\n0\r\n\r\n"
+        HttpParser.chunked_encode(response, chunk)
+        response << CHUNKED_TERMINATOR
         socket_write(socket, response)
       else
         socket_writev(socket, [response, chunk])
@@ -1244,15 +1190,13 @@ module Raptor
         body_array.each do |chunk|
           raise TypeError, "body must yield String values" unless chunk.is_a?(String)
 
-          next if chunk.empty?
-
-          buffer << chunk.bytesize.to_s(16) << "\r\n" << chunk << "\r\n"
+          HttpParser.chunked_encode(buffer, chunk)
           if buffer.bytesize >= CHUNKED_WRITE_THRESHOLD
             socket_write(socket, buffer)
             buffer = +""
           end
         end
-        buffer << "0\r\n\r\n"
+        buffer << CHUNKED_TERMINATOR
         socket_write(socket, buffer)
       else
         body_array.each do |chunk|
@@ -1275,14 +1219,15 @@ module Raptor
     def write_enumerable_body(socket, response, body, use_chunked)
       if use_chunked
         socket_write(socket, response)
+        buffer = +""
         body.each do |chunk|
           raise TypeError, "body must yield String values" unless chunk.is_a?(String)
 
-          next if chunk.empty?
-
-          socket_write(socket, "#{chunk.bytesize.to_s(16)}\r\n#{chunk}\r\n")
+          buffer.clear
+          HttpParser.chunked_encode(buffer, chunk)
+          socket_write(socket, buffer) unless buffer.empty?
         end
-        socket_write(socket, "0\r\n\r\n")
+        socket_write(socket, CHUNKED_TERMINATOR)
       else
         body.each do |chunk|
           raise TypeError, "body must yield String values" unless chunk.is_a?(String)
@@ -1293,72 +1238,6 @@ module Raptor
       end
     end
 
-    # Returns true if the header key contains characters illegal in HTTP headers.
-    #
-    # @param key [String] the header key to check
-    # @return [Boolean] true if the key is illegal
-    #
-    # @rbs (String key) -> bool
-    def illegal_header_key?(key)
-      key.match?(ILLEGAL_HEADER_KEY_REGEX)
-    end
-
-    # Returns true if the header value contains characters illegal in HTTP headers.
-    #
-    # @param value [String] the header value to check
-    # @return [Boolean] true if the value is illegal
-    #
-    # @rbs (String value) -> bool
-    def illegal_header_value?(value)
-      value.match?(ILLEGAL_HEADER_VALUE_REGEX)
-    end
-
-    # Appends normalised header lines to `result`. Skips entries with
-    # illegal keys or values. Array values are written as separate lines.
-    #
-    # @param headers [Hash] normalized response headers
-    # @return [String] formatted header lines, each ending with CRLF
-    #
-    # @rbs (String result, Hash[String, String | Array[String]] headers) -> void
-    def format_headers(result, headers)
-      headers.each do |name, value|
-        next if illegal_header_key?(name)
-
-        if value.is_a?(Array)
-          value.each { |entry| append_header_value(result, name, entry) }
-        else
-          append_header_value(result, name, value)
-        end
-      end
-    end
-
-    # Appends one or more `name: value` header lines to `result`, splitting
-    # newline-joined values across separate lines and skipping empty or
-    # illegal values.
-    #
-    # @param result [String] the buffer to append to
-    # @param name [String] the header name
-    # @param value [Object] the header value (any object responding to `to_s`)
-    # @return [void]
-    #
-    # @rbs (String result, String name, untyped value) -> void
-    def append_header_value(result, name, value)
-      string_value = value.is_a?(String) ? value : value.to_s
-      return if string_value.empty?
-
-      if string_value.include?("\n")
-        string_value.split("\n").each do |line|
-          next if line.empty? || illegal_header_value?(line)
-
-          result << name << ": " << line << "\r\n"
-        end
-      else
-        return if illegal_header_value?(string_value)
-
-        result << name << ": " << string_value << "\r\n"
-      end
-    end
-
     # Calls every `rack.response_finished` callback in reverse
     # registration order, rescuing any that raise.
     #

data/lib/raptor/http2.rb

@@ -229,8 +229,6 @@ module Raptor
     MAX_FRAME_SIZE = 16_384
 
     SERVER_PROTOCOL = "HTTP/2"
-    RACK_HEADER_PREFIX = "rack."
-    HOP_BY_HOP_HEADERS = ["connection", "transfer-encoding", "keep-alive", "upgrade", "proxy-connection"].freeze
 
     REQUEST_PSEUDO_HEADERS = [":method", ":scheme", ":path", ":authority"].freeze
     REQUIRED_REQUEST_PSEUDO_HEADERS = [":method", ":scheme", ":path"].freeze
@@ -766,20 +764,7 @@ module Raptor
     def write_http2_response(socket, writer, flow_control, stream_id, status, headers, body)
       parser = Http2Parser.new
 
-      header_pairs = [[":status", status.to_s]]
-      headers.each do |name, value|
-        lowered = name.downcase
-        next if lowered.start_with?(RACK_HEADER_PREFIX)
-        next if HOP_BY_HOP_HEADERS.include?(lowered)
-
-        if value.is_a?(Array)
-          value.each { |entry| header_pairs << [lowered, entry.to_s] }
-        else
-          header_pairs << [lowered, value.to_s]
-        end
-      end
-
-      encoded_headers = parser.encode_headers(header_pairs)
+      encoded_headers = parser.encode_response_headers(status, headers)
       body_chunks = []
       body_bytes = 0
       body.each do |chunk|

data/lib/raptor/reuseport_bpf.rb

@@ -10,8 +10,8 @@ rescue LoadError
 end
 
 module Raptor
-  # Routes incoming connections across worker processes to the worker with
-  # the lowest reactor backlog.
+  # Routes incoming connections across worker processes using two-choice
+  # load sampling, atomically reserving the selected slot before routing.
   #
   # Auto-enabled on Linux when the `libbpf-ruby` gem is installed and the
   # BPF object file has been compiled. Falls back silently to standard
@@ -47,7 +47,7 @@ module Raptor
       return false unless supported?
 
       @object = LibBPFRuby::Object.new(BPF_OBJECT_PATH)
-      @program_fd = @object.program_fd("select_least_loaded")
+      @program_fd = @object.program_fd("select_less_loaded")
       @socks_fd = @object.map_fd("socks")
       @loads_fd = @object.map_fd("loads")
 
@@ -99,6 +99,7 @@ module Raptor
     def self.enable_load_reporting(worker_index)
       @load_key = [worker_index + 1].pack("L")
       @load_value = String.new("\x00\x00\x00\x00", encoding: Encoding::ASCII_8BIT)
+      @accepted_load_value = String.new("\x00\x00\x00\x00", encoding: Encoding::ASCII_8BIT)
     end
 
     # Publishes this worker's current backlog to the BPF map.
@@ -115,6 +116,22 @@ module Raptor
       LibBPFRuby.map_update(@loads_fd, @load_key, @load_value)
     end
 
+    # Publishes an accept-side backlog estimate. This uses a separate value
+    # buffer because the server and load reporter call into the map from
+    # different threads.
+    #
+    # @param backlog [Integer] the estimated backlog after accepting a socket
+    # @return [void]
+    #
+    # @rbs (Integer backlog) -> void
+    def self.update_accepted_load(backlog)
+      @accepted_load_value.setbyte(0, backlog & 0xff)
+      @accepted_load_value.setbyte(1, (backlog >> 8) & 0xff)
+      @accepted_load_value.setbyte(2, (backlog >> 16) & 0xff)
+      @accepted_load_value.setbyte(3, (backlog >> 24) & 0xff)
+      LibBPFRuby.map_update(@loads_fd, @load_key, @accepted_load_value)
+    end
+
     # Marks a worker's slot as unavailable by parking its load at the
     # sentinel maximum so the BPF program's least-loaded pick skips it.
     #

data/lib/raptor/server.rb

@@ -152,8 +152,9 @@ module Raptor
       end
     end
 
-    # Accepts a connection from the given listener and dispatches it into
-    # the HTTP/1.1 or SSL/HTTP-2 pipeline.
+    # Accepts a connection from the given listener, immediately publishes
+    # the pending work to the BPF map, and dispatches the socket into the
+    # HTTP/1.1 or SSL/HTTP-2 pipeline.
     #
     # @param listener [TCPServer, UNIXServer, Binder::SslListener] the ready listener
     # @return [Boolean] true if a connection was accepted, false if the listener had nothing to dispatch
@@ -172,6 +173,8 @@ module Raptor
         remote_addr = DEFAULT_REMOTE_ADDR
       end
 
+      ReuseportBPF.update_accepted_load(@reactor.backlog + 1) if @bpf_active
+
       if listener.is_a?(Binder::SslListener)
         @thread_pool << proc do
           dispatch_ssl_connection(listener, tcp_client, remote_addr)

data/lib/raptor/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Raptor
-  VERSION = "0.16.1"
+  VERSION = "0.17.0"
 end

data/sig/generated/raptor/http1.rbs

@@ -12,8 +12,6 @@ module Raptor
 
     FILE_CHUNK_SIZE: untyped
 
-    MAX_CHUNK_OVERHEAD: untyped
-
     READ_BUFFER_SIZE: untyped
 
     RESPONSE_BUFFER_CAPACITY: untyped
@@ -30,8 +28,6 @@ module Raptor
 
     STATUS_LINE_CACHE_11: untyped
 
-    STATUS_WITH_NO_ENTITY_BODY: untyped
-
     CONTINUE_RESPONSE: ::String
 
     BAD_REQUEST_RESPONSE: ::String
@@ -48,6 +44,8 @@ module Raptor
 
     TRANSFER_ENCODING_CHUNKED: ::String
 
+    CHUNKED_TERMINATOR: ::String
+
     HTTP_CONNECTION: ::String
 
     HTTP_EXPECT: ::String
@@ -60,12 +58,6 @@ module Raptor
 
     RACK_HIJACK_IO: ::String
 
-    ILLEGAL_HEADER_KEY_REGEX: ::Regexp
-
-    ILLEGAL_HEADER_VALUE_REGEX: ::Regexp
-
-    CHUNK_SIZE_REGEX: ::Regexp
-
     # Returns true when an HTTP/1.1 request lacks a valid `Host` header per
     # RFC 9112 section 3.2, where a valid value is a non-empty single-value
     # line.
@@ -88,21 +80,6 @@ module Raptor
     # @rbs (Hash[String, untyped] env) -> bool
     def self.request_smuggling?: (Hash[String, untyped] env) -> bool
 
-    # Decodes a chunked transfer-encoded body buffer.
-    #
-    # Returns the decoded bytes and a state symbol: `:complete` when the
-    # terminating zero-length chunk and trailer section were fully consumed,
-    # `:too_large` when the decoded size would exceed `max_size`, `:malformed`
-    # when a chunk-size line is not valid hex or chunk framing overhead exceeds
-    # `MAX_CHUNK_OVERHEAD`, or `:incomplete` otherwise.
-    #
-    # @param buffer [String] the raw body buffer to decode
-    # @param max_size [Integer, nil] maximum decoded body size, or nil for unlimited
-    # @return [Array(String, Symbol)] decoded body and completion state
-    #
-    # @rbs (String buffer, ?Integer? max_size) -> [String, Symbol]
-    def self.decode_chunked: (String buffer, ?Integer? max_size) -> [ String, Symbol ]
-
     # Advances an HTTP/1.x request parse from the state hash's buffered
     # bytes. A complete well-formed request returns with `:complete` set
     # plus populated `:env` and `:body`; malformed or oversized input flips
@@ -117,27 +94,27 @@ module Raptor
     # @rbs (Hash[Symbol, untyped] data, Hash[String, untyped] env_template, Integer? max_body_size) -> Hash[Symbol, untyped]
     def self.parse: (Hash[Symbol, untyped] data, Hash[String, untyped] env_template, Integer? max_body_size) -> Hash[Symbol, untyped]
 
-    @env_template: Hash[String, untyped]
+    @app: ^(Hash[String, untyped]) -> [ Integer, Hash[String, String | Array[String]], untyped ]
 
-    @running: AtomicBoolean
+    @server_port: Integer
 
-    @on_error: ^(Hash[String, untyped]?, Exception) -> void | nil
+    @server_port_string: String
 
-    @access_log_io: IO?
+    @write_timeout: Integer
 
-    @max_keepalive_requests: Integer
+    @max_body_size: Integer?
 
     @body_spool_threshold: Integer?
 
-    @max_body_size: Integer?
+    @max_keepalive_requests: Integer
 
-    @write_timeout: Integer
+    @access_log_io: IO?
 
-    @server_port_string: String
+    @on_error: ^(Hash[String, untyped]?, Exception) -> void | nil
 
-    @server_port: Integer
+    @running: AtomicBoolean
 
-    @app: ^(Hash[String, untyped]) -> [ Integer, Hash[String, String | Array[String]], untyped ]
+    @env_template: Hash[String, untyped]
 
     # Creates a new Http1 handler.
     #
@@ -470,11 +447,12 @@ module Raptor
     #
     # @param headers [Hash] normalized response headers
     # @param status [Integer] HTTP status code
+    # @param no_entity_body [Boolean] whether the status forbids an entity body
     # @return [void]
     # @raise [ArgumentError] if a forbidden header is present for the status
     #
-    # @rbs (Hash[String, String | Array[String]] headers, Integer status) -> void
-    def validate_headers: (Hash[String, String | Array[String]] headers, Integer status) -> void
+    # @rbs (Hash[String, String | Array[String]] headers, Integer status, bool no_entity_body) -> void
+    def validate_headers: (Hash[String, String | Array[String]] headers, Integer status, bool no_entity_body) -> void
 
     # Returns the HTTP status line for `status`.
     #
@@ -504,11 +482,11 @@ module Raptor
     # @param socket [TCPSocket] the client socket
     # @param response [String] the status line accumulated so far
     # @param headers [Hash] normalized response headers
-    # @param status [Integer] HTTP status code
+    # @param no_entity_body [Boolean] whether the response status forbids an entity body
     # @return [void]
     #
-    # @rbs (TCPSocket socket, String response, Hash[String, String | Array[String]] headers, Integer status) -> void
-    def write_no_body_response: (TCPSocket socket, String response, Hash[String, String | Array[String]] headers, Integer status) -> void
+    # @rbs (TCPSocket socket, String response, Hash[String, String | Array[String]] headers, bool no_entity_body) -> void
+    def write_no_body_response: (TCPSocket socket, String response, Hash[String, String | Array[String]] headers, bool no_entity_body) -> void
 
     # Writes a complete response with a body. Emits a `Content-Length`
     # when the total size is known upfront, otherwise chunked encoding on
@@ -592,43 +570,6 @@ module Raptor
     # @rbs (TCPSocket socket, String response, untyped body, bool use_chunked) -> void
     def write_enumerable_body: (TCPSocket socket, String response, untyped body, bool use_chunked) -> void
 
-    # Returns true if the header key contains characters illegal in HTTP headers.
-    #
-    # @param key [String] the header key to check
-    # @return [Boolean] true if the key is illegal
-    #
-    # @rbs (String key) -> bool
-    def illegal_header_key?: (String key) -> bool
-
-    # Returns true if the header value contains characters illegal in HTTP headers.
-    #
-    # @param value [String] the header value to check
-    # @return [Boolean] true if the value is illegal
-    #
-    # @rbs (String value) -> bool
-    def illegal_header_value?: (String value) -> bool
-
-    # Appends normalised header lines to `result`. Skips entries with
-    # illegal keys or values. Array values are written as separate lines.
-    #
-    # @param headers [Hash] normalized response headers
-    # @return [String] formatted header lines, each ending with CRLF
-    #
-    # @rbs (String result, Hash[String, String | Array[String]] headers) -> void
-    def format_headers: (String result, Hash[String, String | Array[String]] headers) -> void
-
-    # Appends one or more `name: value` header lines to `result`, splitting
-    # newline-joined values across separate lines and skipping empty or
-    # illegal values.
-    #
-    # @param result [String] the buffer to append to
-    # @param name [String] the header name
-    # @param value [Object] the header value (any object responding to `to_s`)
-    # @return [void]
-    #
-    # @rbs (String result, String name, untyped value) -> void
-    def append_header_value: (String result, String name, untyped value) -> void
-
     # Calls every `rack.response_finished` callback in reverse
     # registration order, rescuing any that raise.
     #

data/sig/generated/raptor/http2.rbs

@@ -132,10 +132,6 @@ module Raptor
 
     SERVER_PROTOCOL: ::String
 
-    RACK_HEADER_PREFIX: ::String
-
-    HOP_BY_HOP_HEADERS: untyped
-
     REQUEST_PSEUDO_HEADERS: untyped
 
     REQUIRED_REQUEST_PSEUDO_HEADERS: untyped

data/sig/generated/raptor/reuseport_bpf.rbs

@@ -1,8 +1,8 @@
 # Generated from lib/raptor/reuseport_bpf.rb with RBS::Inline
 
 module Raptor
-  # Routes incoming connections across worker processes to the worker with
-  # the lowest reactor backlog.
+  # Routes incoming connections across worker processes using two-choice
+  # load sampling, atomically reserving the selected slot before routing.
   #
   # Auto-enabled on Linux when the `libbpf-ruby` gem is installed and the
   # BPF object file has been compiled. Falls back silently to standard
@@ -62,6 +62,16 @@ module Raptor
     # @rbs (Integer backlog) -> void
     def self.update_load: (Integer backlog) -> void
 
+    # Publishes an accept-side backlog estimate. This uses a separate value
+    # buffer because the server and load reporter call into the map from
+    # different threads.
+    #
+    # @param backlog [Integer] the estimated backlog after accepting a socket
+    # @return [void]
+    #
+    # @rbs (Integer backlog) -> void
+    def self.update_accepted_load: (Integer backlog) -> void
+
     # Marks a worker's slot as unavailable by parking its load at the
     # sentinel maximum so the BPF program's least-loaded pick skips it.
     #

data/sig/generated/raptor/server.rbs

@@ -98,8 +98,9 @@ module Raptor
     # @rbs () -> void
     def drain_accept_queue: () -> void
 
-    # Accepts a connection from the given listener and dispatches it into
-    # the HTTP/1.1 or SSL/HTTP-2 pipeline.
+    # Accepts a connection from the given listener, immediately publishes
+    # the pending work to the BPF map, and dispatches the socket into the
+    # HTTP/1.1 or SSL/HTTP-2 pipeline.
     #
     # @param listener [TCPServer, UNIXServer, Binder::SslListener] the ready listener
     # @return [Boolean] true if a connection was accepted, false if the listener had nothing to dispatch

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: raptor
 version: !ruby/object:Gem::Version
-  version: 0.16.1
+  version: 0.17.0
 platform: ruby
 authors:
 - Joshua Young