fast_curl 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa97f9eaef2dd36adbff2816b3ab08ec7e924b7a7a23c01c7c38723c6f071ff3
-  data.tar.gz: 5c5e02905534b2c54602b9f970fab2d587603f7c31ab6a0ab251bd6a1857932b
+  metadata.gz: 00f4a847ee360180fa617212693206970a8e7af85ef02e6370d37cb62d2b384e
+  data.tar.gz: f5633dc59f41b4b31efa6e07eb32bc6a85b146e85126fa68b24b742294df5e8b
 SHA512:
-  metadata.gz: 54c9d82c53ab24b08129c38cda9a82e06d834cf16f4b2b210f62edd2361c77db84f49eb59e3cbcbfc04d94dc12a758d89bc6e65bed23183132e8365186892716
-  data.tar.gz: 354ee56ed5973a66f365f76eb0f2a01264ae3e14e238ff616cd34d6251f10830babda151037a713b7e17573bb209387e05713b19b291c573b31cf11099ecb3b7
+  metadata.gz: b7f2e299c89da40d0a546e8545310430a46f0cca8abafff53e46953871c4c205d8fc53c16e33e65b9ff3a22c951d212f41f562476977200de84136ce0342cacc
+  data.tar.gz: a5fa06d7e44c0846de3cccd3c955a136fd7ee05e01611f05b940bf174cbd356315d23418ebc40ea77d94667c928ae3f2c7087c227df0ea7a39c0b3a27f52da77

data/README.md

@@ -12,7 +12,9 @@ Ultra-fast parallel HTTP client for Ruby. C extension built on libcurl `curl_mul
 
 ## Installation
 
-**Requirements**: Ruby >= 3.0 (for Fiber scheduler support)
+**Requirements**: Ruby >= 3.1, libcurl
+
+> **Why Ruby 3.1?** The C extension uses `rb_fiber_scheduler_current`, `rb_fiber_scheduler_block` and `rb_fiber_scheduler_unblock` to properly yield control to the Fiber Scheduler during I/O. These APIs are stable starting from Ruby 3.1. Without them, there is no correct way for a C extension to cooperate with the scheduler — earlier approaches (`rb_thread_schedule`) hold the GVL and block other fibers.
 
 ```ruby
 gem 'fast_curl'
@@ -76,6 +78,23 @@ FastCurl.stream_get(urls, connections: 50) do |index, response|
 end
 ```
 
+### Retry functionality (v0.2.0+)
+
+```ruby
+# Automatic retry on network errors (timeout, connection issues)
+results = FastCurl.get([
+  { url: "https://unreliable-api.com/data" }
+], retries: 3, retry_delay: 1000)  # 3 retries with 1s delay
+
+# Retry on specific HTTP status codes
+results = FastCurl.get([
+  { url: "https://api.example.com/data" }
+], retries: 2, retry_codes: [500, 502, 503], retry_delay: 500)
+
+# Disable retries (default is 1 retry)
+results = FastCurl.get(urls, retries: 0)
+```
+
 ### Inside Async
 
 ```ruby
@@ -119,22 +138,60 @@ end
 |---|---|---|
 | `connections` | 20 | Max parallel connections |
 | `timeout` | 30 | Per-request timeout in seconds |
+| `retries` | 1 | Number of retry attempts (0-10) |
+| `retry_delay` | 0 | Delay between retries in milliseconds |
+| `retry_codes` | [] | HTTP status codes to retry on |
 
 ## Performance
 
-Benchmark results (`bundle exec ruby benchmark/local_bench.rb`):
+Benchmarks against `httpbin.org`, 5 iterations with 1 warmup, median times.
+Run yourself: `bundle exec ruby benchmark/local_bench.rb`.
+
+Each request hits `/delay/1` (server-side 1-second delay), so sequential baseline
+grows linearly while parallel clients stay near ~1s plus network overhead.
+
+### Time to completion (lower is better)
+
+| Scenario                        | Net::HTTP sequential | fast_curl (thread) | fast_curl (fiber/Async) | Async::HTTP::Internet |
+|---------------------------------|---------------------:|-------------------:|------------------------:|----------------------:|
+| 4 requests × 1s, conn=4         |                8.27s |              2.36s |                   2.13s |                 2.56s |
+| 10 requests × 1s, conn=10       |               20.92s |              3.49s |                   5.23s |                 3.83s |
+| 20 requests × 1s, conn=5        |               42.56s |              2.94s |                   2.90s |                12.14s |
+| 200 requests × 1s, conn=20      |                   —  |             22.19s |                  21.77s |                23.59s |
+
+### Speedup vs Net::HTTP (median)
+
+| Scenario                          | fast_curl (thread) | fast_curl (fiber) | Async::HTTP |
+|-----------------------------------|-------------------:|------------------:|------------:|
+| 4 requests × 1s                   |           **3.5x** |              3.9x |        3.2x |
+| 10 requests × 1s                  |           **6.0x** |              4.0x |        5.5x |
+| 20 requests × 1s (queued, conn=5) |          **14.5x** |             14.7x |        3.5x |
+
+### Memory & allocations per request batch (lower is better)
+
+| Scenario                        | fast_curl (thread) allocated | fast_curl (fiber) allocated | Async::HTTP allocated |
+|---------------------------------|-----------------------------:|----------------------------:|----------------------:|
+| 4 requests × 1s                 |                 **278 obj**  |                     350 obj |             2,433 obj |
+| 10 requests × 1s                |                 **490 obj**  |                     756 obj |             4,763 obj |
+| 20 requests × 1s, conn=5        |                 **621 obj**  |                     750 obj |             8,536 obj |
+| 200 requests × 1s, conn=20      |               **5,188 obj**  |                   5,642 obj |            78,203 obj |
+
+Ruby heap delta stays near zero across all scenarios for fast_curl — most allocation
+happens in C, not on the Ruby heap.
+
+### Error handling
+
+| Scenario                                                     |  Time |
+|--------------------------------------------------------------|------:|
+| 4 mixed requests (404, 500, DNS fail, 30s delay), timeout=2s | 4.02s |
+
+Bounded by `timeout=2s` rather than by the slow request.
 
-| Method | 4 parallel | 10 parallel | 20 parallel | 200 parallel |
-|--------|------------|-------------|--------------|---------------|
-| Net::HTTP sequential | 7.93s (+2.1 MB) | 24.20s (+0.3 MB) | 48.58s (+1.2 MB) | - |
-| fast_curl (thread) | 2.09s (+0.7 MB) | 3.73s (+0.9 MB) | 3.76s (+0.0 MB) | 5.88s (+2.3 MB) |
-| fast_curl (fiber) | 1.96s (+0.4 MB) | 4.86s (+0.0 MB) | 3.71s (+0.2 MB) | 9.60s (+1.6 MB) |
-| Async::HTTP | 2.54s (+0.3 MB) | 4.27s (+0.4 MB) | 9.16s (+0.5 MB) | 22.44s (+10.7 MB) |
+### Notes on the numbers
 
-Additional scenarios:
-- Stream execute (5 requests): 5.99s (+0.0 MB)
-- First execute (first 1 of 5): 2.40s (+0.0 MB)
-- Error handling (timeout=2s): 2.01s (+0.0 MB)
+- **Net::HTTP sequential** is the proof-of-parallelism baseline — it confirms fast_curl and Async are actually running concurrently, not that they "beat" a different library. 4×1s sequentially = 4s, parallel = ~1s + overhead.
+- **Variance is high against remote endpoints** (httpbin.org). For stable numbers, use `--local` which spawns a WEBrick server on 127.0.0.1.
+- **fast_curl (thread) vs (fiber)**: same underlying C code, different scheduling. "thread" is the default; "fiber" kicks in automatically when called inside `Async do ... end`.
 
 ## License
 

data/ext/fast_curl/extconf.rb

@@ -6,6 +6,7 @@ abort "curl/curl.h is required" unless have_header("curl/curl.h")
 have_header("ruby/thread.h")
 have_header("ruby/fiber/scheduler.h")
 
+have_func("curl_multi_wakeup", "curl/curl.h")
 have_func("rb_fiber_scheduler_current", "ruby.h")
 have_func("rb_io_wait", "ruby.h")
 

data/ext/fast_curl/fast_curl.c

@@ -11,31 +11,28 @@
 #define MAX_RESPONSE_SIZE     (100 * 1024 * 1024)
 #define MAX_REDIRECTS         5
 #define MAX_TIMEOUT           300
+#define MAX_RETRIES           10
+#define MAX_REQUESTS          10000
+#define DEFAULT_RETRIES       1
+#define DEFAULT_RETRY_DELAY   0
 #define INITIAL_BUF_CAP       8192
 #define INITIAL_HEADER_CAP    16
 #define POLL_TIMEOUT_MS       50
 #define FIBER_POLL_TIMEOUT_MS 10
 #define HEADER_LINE_BUF_SIZE  512
 
-static ID id_status;
-static ID id_headers;
-static ID id_body;
-static ID id_error_code;
-static ID id_url;
-static ID id_method;
-static ID id_timeout;
-static ID id_connections;
-static ID id_count;
-static ID id_keys;
-static VALUE sym_status;
-static VALUE sym_headers;
-static VALUE sym_body;
-static VALUE sym_error_code;
-static VALUE sym_url;
-static VALUE sym_method;
-static VALUE sym_timeout;
-static VALUE sym_connections;
-static VALUE sym_count;
+static const CURLcode DEFAULT_RETRYABLE_CURLE[] = {
+    CURLE_COULDNT_CONNECT, CURLE_OPERATION_TIMEDOUT, CURLE_SEND_ERROR,       CURLE_RECV_ERROR,
+    CURLE_GOT_NOTHING,     CURLE_PARTIAL_FILE,       CURLE_SSL_CONNECT_ERROR};
+#define DEFAULT_RETRYABLE_CURLE_COUNT \
+    (int)(sizeof(DEFAULT_RETRYABLE_CURLE) / sizeof(DEFAULT_RETRYABLE_CURLE[0]))
+
+static ID id_status, id_headers, id_body, id_error_code, id_url, id_method;
+static ID id_timeout, id_connections, id_count, id_keys;
+static ID id_retries, id_retry_delay, id_retry_codes;
+static VALUE sym_status, sym_headers, sym_body, sym_error_code, sym_url, sym_method;
+static VALUE sym_timeout, sym_connections, sym_count;
+static VALUE sym_retries, sym_retry_delay, sym_retry_codes;
 
 typedef struct {
     char *data;
@@ -60,29 +57,27 @@ static inline void buffer_free(buffer_t *buf) {
     buf->cap = 0;
 }
 
+static inline void buffer_reset(buffer_t *buf) {
+    buf->len = 0;
+}
+
 static size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
     buffer_t *buf = (buffer_t *)userdata;
     size_t total = size * nmemb;
-
-    if (buf->len + total > buf->max_size) {
+    if (buf->len + total > buf->max_size)
         return 0;
-    }
-
     if (buf->len + total >= buf->cap) {
         size_t new_cap = (buf->cap == 0) ? INITIAL_BUF_CAP : buf->cap;
         while (new_cap <= buf->len + total)
             new_cap *= 2;
-
         if (new_cap > buf->max_size)
             new_cap = buf->max_size;
-
         char *new_data = realloc(buf->data, new_cap);
         if (!new_data)
             return 0;
         buf->data = new_data;
         buf->cap = new_cap;
     }
-
     memcpy(buf->data + buf->len, ptr, total);
     buf->len += total;
     return total;
@@ -114,36 +109,36 @@ static void header_list_free(header_list_t *h) {
     h->cap = 0;
 }
 
+static void header_list_reset(header_list_t *h) {
+    for (int i = 0; i < h->count; i++)
+        free(h->entries[i].str);
+    h->count = 0;
+}
+
 static size_t header_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
     header_list_t *h = (header_list_t *)userdata;
     size_t total = size * nmemb;
-
     if (total <= 2)
         return total;
-
     if (h->count >= h->cap) {
         int new_cap = (h->cap == 0) ? INITIAL_HEADER_CAP : h->cap * 2;
-        header_entry_t *new_entries = realloc(h->entries, sizeof(header_entry_t) * new_cap);
-        if (!new_entries)
+        header_entry_t *ne = realloc(h->entries, sizeof(header_entry_t) * new_cap);
+        if (!ne)
             return 0;
-        h->entries = new_entries;
+        h->entries = ne;
         h->cap = new_cap;
     }
-
     size_t stripped = total;
     while (stripped > 0 && (ptr[stripped - 1] == '\r' || ptr[stripped - 1] == '\n'))
         stripped--;
-
     char *entry = malloc(stripped + 1);
     if (!entry)
         return 0;
     memcpy(entry, ptr, stripped);
     entry[stripped] = '\0';
-
     h->entries[h->count].str = entry;
     h->entries[h->count].len = stripped;
     h->count++;
-
     return size * nmemb;
 }
 
@@ -154,6 +149,8 @@ typedef struct {
     header_list_t headers;
     struct curl_slist *req_headers;
     int done;
+    CURLcode curl_result;
+    long http_status;
 } request_ctx_t;
 
 static inline void request_ctx_init(request_ctx_t *ctx, int index) {
@@ -163,6 +160,8 @@ static inline void request_ctx_init(request_ctx_t *ctx, int index) {
     header_list_init(&ctx->headers);
     ctx->req_headers = NULL;
     ctx->done = 0;
+    ctx->curl_result = CURLE_OK;
+    ctx->http_status = 0;
 }
 
 static void request_ctx_free(request_ctx_t *ctx) {
@@ -178,6 +177,26 @@ static void request_ctx_free(request_ctx_t *ctx) {
     }
 }
 
+static int request_ctx_reset_for_retry(request_ctx_t *ctx) {
+    if (ctx->easy) {
+        curl_easy_cleanup(ctx->easy);
+        ctx->easy = NULL;
+    }
+    buffer_reset(&ctx->body);
+    header_list_reset(&ctx->headers);
+    if (ctx->req_headers) {
+        curl_slist_free_all(ctx->req_headers);
+        ctx->req_headers = NULL;
+    }
+    ctx->easy = curl_easy_init();
+    if (!ctx->easy)
+        return 0;
+    ctx->done = 0;
+    ctx->curl_result = CURLE_OK;
+    ctx->http_status = 0;
+    return 1;
+}
+
 typedef struct {
     CURLM *multi;
     request_ctx_t *requests;
@@ -185,87 +204,134 @@ typedef struct {
     int still_running;
     long timeout_ms;
     int max_connections;
+    volatile int cancelled;
 } multi_session_t;
 
+typedef struct {
+    int max_retries;
+    long retry_delay_ms;
+    int *retry_http_codes;
+    int retry_http_count;
+} retry_config_t;
+
+static int contains_header_injection(const char *str, long len) {
+    for (long i = 0; i < len; i++) {
+        if (str[i] == '\r' || str[i] == '\n' || str[i] == '\0')
+            return 1;
+    }
+    return 0;
+}
+
+#ifdef HAVE_RB_FIBER_SCHEDULER_CURRENT
+static VALUE current_fiber_scheduler(void) {
+    VALUE sched = rb_fiber_scheduler_current();
+    if (sched == Qnil || sched == Qfalse)
+        return Qnil;
+    return sched;
+}
+#else
+static VALUE current_fiber_scheduler(void) {
+    return Qnil;
+}
+#endif
+
+typedef struct {
+    void *(*func)(void *);
+    void *arg;
+    VALUE scheduler;
+    VALUE blocker;
+    VALUE fiber;
+} fiber_worker_ctx_t;
+
+static void *fiber_worker_nogvl(void *arg) {
+    fiber_worker_ctx_t *c = (fiber_worker_ctx_t *)arg;
+    c->func(c->arg);
+    return NULL;
+}
+
+static VALUE fiber_worker_thread(void *arg) {
+    fiber_worker_ctx_t *c = (fiber_worker_ctx_t *)arg;
+    rb_thread_call_without_gvl(fiber_worker_nogvl, c, RUBY_UBF_PROCESS, NULL);
+    rb_fiber_scheduler_unblock(c->scheduler, c->blocker, c->fiber);
+    return Qnil;
+}
+
+static void run_via_fiber_worker(VALUE scheduler, void *(*func)(void *), void *arg) {
+    fiber_worker_ctx_t ctx = {
+        .func = func,
+        .arg = arg,
+        .scheduler = scheduler,
+        .blocker = rb_obj_alloc(rb_cObject),
+        .fiber = rb_fiber_current(),
+    };
+    VALUE th = rb_thread_create(fiber_worker_thread, &ctx);
+    rb_fiber_scheduler_block(scheduler, ctx.blocker, Qnil);
+    rb_funcall(th, rb_intern("join"), 0);
+}
+
 static VALUE build_response(request_ctx_t *ctx) {
     long status = 0;
     curl_easy_getinfo(ctx->easy, CURLINFO_RESPONSE_CODE, &status);
-
     VALUE headers_hash = rb_hash_new();
     for (int i = 0; i < ctx->headers.count; i++) {
         const char *hdr = ctx->headers.entries[i].str;
         size_t hdr_len = ctx->headers.entries[i].len;
-
         const char *colon = memchr(hdr, ':', hdr_len);
         if (!colon)
             continue;
-
         VALUE key = rb_str_new(hdr, colon - hdr);
-
-        const char *val_start = colon + 1;
-        const char *val_end = hdr + hdr_len;
-
-        while (val_start < val_end && (*val_start == ' ' || *val_start == '\t'))
-            val_start++;
-
-        while (val_end > val_start && (*(val_end - 1) == ' ' || *(val_end - 1) == '\t'))
-            val_end--;
-
-        VALUE val = rb_str_new(val_start, val_end - val_start);
+        const char *vs = colon + 1, *ve = hdr + hdr_len;
+        while (vs < ve && (*vs == ' ' || *vs == '\t'))
+            vs++;
+        while (ve > vs && (*(ve - 1) == ' ' || *(ve - 1) == '\t'))
+            ve--;
+        VALUE val = rb_str_new(vs, ve - vs);
         rb_hash_aset(headers_hash, key, val);
     }
-
     VALUE body_str =
         ctx->body.data ? rb_str_new(ctx->body.data, ctx->body.len) : rb_str_new_cstr("");
-
     VALUE result = rb_hash_new();
     rb_hash_aset(result, sym_status, LONG2NUM(status));
     rb_hash_aset(result, sym_headers, headers_hash);
     rb_hash_aset(result, sym_body, body_str);
-
     return result;
 }
 
 static VALUE build_error_response(const char *message) {
-    VALUE result = rb_hash_new();
-    rb_hash_aset(result, sym_status, INT2NUM(0));
-    rb_hash_aset(result, sym_headers, Qnil);
-    rb_hash_aset(result, sym_body, rb_str_new_cstr(message));
-    return result;
+    VALUE r = rb_hash_new();
+    rb_hash_aset(r, sym_status, INT2NUM(0));
+    rb_hash_aset(r, sym_headers, Qnil);
+    rb_hash_aset(r, sym_body, rb_str_new_cstr(message));
+    return r;
 }
 
 static VALUE build_error_response_with_code(const char *message, int error_code) {
-    VALUE result = rb_hash_new();
-    rb_hash_aset(result, sym_status, INT2NUM(0));
-    rb_hash_aset(result, sym_headers, Qnil);
-    rb_hash_aset(result, sym_body, rb_str_new_cstr(message));
-    rb_hash_aset(result, sym_error_code, INT2NUM(error_code));
-    return result;
+    VALUE r = rb_hash_new();
+    rb_hash_aset(r, sym_status, INT2NUM(0));
+    rb_hash_aset(r, sym_headers, Qnil);
+    rb_hash_aset(r, sym_body, rb_str_new_cstr(message));
+    rb_hash_aset(r, sym_error_code, INT2NUM(error_code));
+    return r;
 }
 
 static int is_valid_url(const char *url) {
     if (!url)
         return 0;
-
-    size_t url_len = strlen(url);
-
-    if (url_len < 8 || url_len > 2048)
+    size_t len = strlen(url);
+    if (len < 8 || len > 2048)
         return 0;
-
     if (strncmp(url, "https://", 8) == 0)
         return 1;
-    if (url_len >= 7 && strncmp(url, "http://", 7) == 0)
+    if (len >= 7 && strncmp(url, "http://", 7) == 0)
         return 1;
-
     return 0;
 }
 
-#define CURL_SETOPT_CHECK(handle, option, value)                \
-    do {                                                        \
-        CURLcode res = curl_easy_setopt(handle, option, value); \
-        if (res != CURLE_OK) {                                  \
-            return res;                                         \
-        }                                                       \
+#define CURL_SETOPT_CHECK(handle, option, value)               \
+    do {                                                       \
+        CURLcode _r = curl_easy_setopt(handle, option, value); \
+        if (_r != CURLE_OK)                                    \
+            return _r;                                         \
     } while (0)
 
 static CURLcode setup_basic_options(CURL *easy, const char *url_str, long timeout_sec,
@@ -282,14 +348,12 @@ static CURLcode setup_basic_options(CURL *easy, const char *url_str, long timeou
     CURL_SETOPT_CHECK(easy, CURLOPT_ACCEPT_ENCODING, "");
     CURL_SETOPT_CHECK(easy, CURLOPT_PRIVATE, (char *)ctx);
     CURL_SETOPT_CHECK(easy, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_2TLS);
-
     return CURLE_OK;
 }
 
 static CURLcode setup_security_options(CURL *easy) {
     CURL_SETOPT_CHECK(easy, CURLOPT_SSL_VERIFYPEER, 1L);
     CURL_SETOPT_CHECK(easy, CURLOPT_SSL_VERIFYHOST, 2L);
-
 #ifdef CURLOPT_PROTOCOLS_STR
     CURL_SETOPT_CHECK(easy, CURLOPT_PROTOCOLS_STR, "http,https");
     CURL_SETOPT_CHECK(easy, CURLOPT_REDIR_PROTOCOLS_STR, "http,https");
@@ -297,7 +361,6 @@ static CURLcode setup_security_options(CURL *easy) {
     CURL_SETOPT_CHECK(easy, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
     CURL_SETOPT_CHECK(easy, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
 #endif
-
     return CURLE_OK;
 }
 
@@ -318,46 +381,45 @@ static CURLcode setup_method_and_body(CURL *easy, VALUE method, VALUE body) {
     }
 
     if (!NIL_P(body)) {
-        CURL_SETOPT_CHECK(easy, CURLOPT_POSTFIELDS, StringValuePtr(body));
         CURL_SETOPT_CHECK(easy, CURLOPT_POSTFIELDSIZE, RSTRING_LEN(body));
+        CURL_SETOPT_CHECK(easy, CURLOPT_COPYPOSTFIELDS, StringValuePtr(body));
     }
-
     return CURLE_OK;
 }
 
 static int header_iter_cb(VALUE key, VALUE val, VALUE arg) {
     request_ctx_t *ctx = (request_ctx_t *)arg;
-
     VALUE key_str = rb_String(key);
     const char *k = RSTRING_PTR(key_str);
     long klen = RSTRING_LEN(key_str);
 
+    if (contains_header_injection(k, klen))
+        return ST_CONTINUE;
+
     if (NIL_P(val) || RSTRING_LEN(rb_String(val)) == 0) {
-        char stack_buf[HEADER_LINE_BUF_SIZE];
-        char *buf = stack_buf;
+        char sbuf[HEADER_LINE_BUF_SIZE];
+        char *buf = sbuf;
         long need = klen + 2;
-
         if (need > HEADER_LINE_BUF_SIZE)
             buf = malloc(need);
         if (!buf)
             return ST_CONTINUE;
-
         memcpy(buf, k, klen);
         buf[klen] = ';';
         buf[klen + 1] = '\0';
-
         ctx->req_headers = curl_slist_append(ctx->req_headers, buf);
-
-        if (buf != stack_buf)
+        if (buf != sbuf)
             free(buf);
     } else {
         VALUE val_str = rb_String(val);
         const char *v = RSTRING_PTR(val_str);
         long vlen = RSTRING_LEN(val_str);
-        char stack_buf[HEADER_LINE_BUF_SIZE];
-        char *buf = stack_buf;
-        long need = klen + 2 + vlen + 1;
 
+        if (contains_header_injection(v, vlen))
+            return ST_CONTINUE;
+        char sbuf[HEADER_LINE_BUF_SIZE];
+        char *buf = sbuf;
+        long need = klen + 2 + vlen + 1;
         if (need > HEADER_LINE_BUF_SIZE)
             buf = malloc(need);
         if (!buf)
@@ -368,13 +430,10 @@ static int header_iter_cb(VALUE key, VALUE val, VALUE arg) {
         buf[klen + 1] = ' ';
         memcpy(buf + klen + 2, v, vlen);
         buf[klen + 2 + vlen] = '\0';
-
         ctx->req_headers = curl_slist_append(ctx->req_headers, buf);
-
-        if (buf != stack_buf)
+        if (buf != sbuf)
             free(buf);
     }
-
     return ST_CONTINUE;
 }
 
@@ -383,33 +442,25 @@ static int setup_easy_handle(request_ctx_t *ctx, VALUE request, long timeout_sec
     VALUE method = rb_hash_aref(request, sym_method);
     VALUE headers = rb_hash_aref(request, sym_headers);
     VALUE body = rb_hash_aref(request, sym_body);
-
     if (NIL_P(url))
         return 0;
-
     const char *url_str = StringValueCStr(url);
-
-    if (!is_valid_url(url_str)) {
+    if (!is_valid_url(url_str))
         rb_raise(rb_eArgError, "Invalid URL: %s", url_str);
-    }
 
     CURLcode res;
-
     res = setup_basic_options(ctx->easy, url_str, timeout_sec, ctx);
     if (res != CURLE_OK)
         return 0;
-
     res = setup_security_options(ctx->easy);
     if (res != CURLE_OK)
         return 0;
-
     res = setup_method_and_body(ctx->easy, method, body);
     if (res != CURLE_OK)
         return 0;
 
     if (!NIL_P(headers) && rb_obj_is_kind_of(headers, rb_cHash)) {
         rb_hash_foreach(headers, header_iter_cb, (VALUE)ctx);
-
         if (ctx->req_headers) {
             res = curl_easy_setopt(ctx->easy, CURLOPT_HTTPHEADER, ctx->req_headers);
             if (res != CURLE_OK)
@@ -417,46 +468,29 @@ static int setup_easy_handle(request_ctx_t *ctx, VALUE request, long timeout_sec
         }
     }
 
+    RB_GC_GUARD(url);
+    RB_GC_GUARD(method);
+    RB_GC_GUARD(headers);
+    RB_GC_GUARD(body);
+    RB_GC_GUARD(request);
     return 1;
 }
 
-static void *perform_without_gvl(void *arg) {
-    multi_session_t *session = (multi_session_t *)arg;
-
-    while (session->still_running > 0) {
-        CURLMcode mc = curl_multi_perform(session->multi, &session->still_running);
-        if (mc != CURLM_OK)
-            break;
-
-        if (session->still_running > 0) {
-            int numfds = 0;
-            mc = curl_multi_poll(session->multi, NULL, 0, POLL_TIMEOUT_MS, &numfds);
-            if (mc != CURLM_OK)
-                break;
-        }
-    }
-
-    return NULL;
-}
-
 static void *poll_without_gvl(void *arg) {
-    multi_session_t *session = (multi_session_t *)arg;
+    multi_session_t *s = (multi_session_t *)arg;
+    if (s->cancelled)
+        return NULL;
     int numfds = 0;
-    curl_multi_poll(session->multi, NULL, 0, POLL_TIMEOUT_MS, &numfds);
-    curl_multi_perform(session->multi, &session->still_running);
+    curl_multi_poll(s->multi, NULL, 0, POLL_TIMEOUT_MS, &numfds);
+    curl_multi_perform(s->multi, &s->still_running);
     return NULL;
 }
 
 static void unblock_perform(void *arg) {
-    (void)arg;
-}
-
-static int has_fiber_scheduler(void) {
-#ifdef HAVE_RB_FIBER_SCHEDULER_CURRENT
-    VALUE scheduler = rb_fiber_scheduler_current();
-    return scheduler != Qnil && scheduler != Qfalse;
-#else
-    return 0;
+    multi_session_t *s = (multi_session_t *)arg;
+    s->cancelled = 1;
+#ifdef HAVE_CURL_MULTI_WAKEUP
+    curl_multi_wakeup(s->multi);
 #endif
 }
 
@@ -470,181 +504,394 @@ typedef struct {
 static int process_completed(multi_session_t *session, completion_ctx_t *cctx) {
     CURLMsg *msg;
     int msgs_left;
-
     while ((msg = curl_multi_info_read(session->multi, &msgs_left))) {
         if (msg->msg != CURLMSG_DONE)
             continue;
-
         request_ctx_t *ctx = NULL;
         curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE, (char **)&ctx);
         if (!ctx || ctx->done)
             continue;
         ctx->done = 1;
-
-        VALUE response;
-        if (msg->data.result == CURLE_OK) {
-            response = build_response(ctx);
+        ctx->curl_result = msg->data.result;
+        if (msg->data.result == CURLE_OK)
+            curl_easy_getinfo(ctx->easy, CURLINFO_RESPONSE_CODE, &ctx->http_status);
+        if (cctx->stream) {
+            VALUE response = (msg->data.result == CURLE_OK)
+                                 ? build_response(ctx)
+                                 : build_error_response_with_code(
+                                       curl_easy_strerror(msg->data.result), (int)msg->data.result);
+            VALUE pair = rb_ary_new_from_args(2, INT2NUM(ctx->index), response);
+            rb_yield(pair);
+            cctx->completed++;
         } else {
-            response = build_error_response_with_code(curl_easy_strerror(msg->data.result),
-                                                      (int)msg->data.result);
+            cctx->completed++;
         }
+        if (cctx->target > 0 && cctx->completed >= cctx->target)
+            return 1;
+    }
+    return 0;
+}
 
-        VALUE pair = rb_ary_new_from_args(2, INT2NUM(ctx->index), response);
+static void run_multi_loop(multi_session_t *session, completion_ctx_t *cctx) {
+    VALUE scheduler = current_fiber_scheduler();
 
-        if (cctx->stream) {
-            rb_yield(pair);
-        } else if (!NIL_P(cctx->results)) {
-            rb_ary_store(cctx->results, ctx->index, pair);
+    if (scheduler != Qnil) {
+        curl_multi_perform(session->multi, &session->still_running);
+        while (session->still_running > 0) {
+            if (session->cancelled)
+                break;
+            run_via_fiber_worker(scheduler, poll_without_gvl, session);
+            if (process_completed(session, cctx))
+                break;
         }
+        process_completed(session, cctx);
+    } else {
+        curl_multi_perform(session->multi, &session->still_running);
+        while (session->still_running > 0) {
+            if (session->cancelled)
+                break;
+            rb_thread_call_without_gvl(poll_without_gvl, session, unblock_perform, session);
+            if (process_completed(session, cctx))
+                break;
+        }
+        process_completed(session, cctx);
+    }
+}
 
-        cctx->completed++;
-
-        if (cctx->target > 0 && cctx->completed >= cctx->target)
+static int is_default_retryable_curle(CURLcode code) {
+    for (int i = 0; i < DEFAULT_RETRYABLE_CURLE_COUNT; i++)
+        if (DEFAULT_RETRYABLE_CURLE[i] == code)
             return 1;
-    }
+    return 0;
+}
 
+static int should_retry(request_ctx_t *ctx, retry_config_t *rc) {
+    if (ctx->curl_result != CURLE_OK)
+        return is_default_retryable_curle(ctx->curl_result);
+    for (int i = 0; i < rc->retry_http_count; i++)
+        if (rc->retry_http_codes[i] == (int)ctx->http_status)
+            return 1;
     return 0;
 }
 
-static void parse_options(VALUE options, long *timeout, int *max_conn) {
+typedef struct {
+    long delay_ms;
+} sleep_arg_t;
+
+static void *sleep_without_gvl(void *arg) {
+    sleep_arg_t *sa = (sleep_arg_t *)arg;
+    struct timespec ts = {.tv_sec = sa->delay_ms / 1000,
+                          .tv_nsec = (sa->delay_ms % 1000) * 1000000L};
+    nanosleep(&ts, NULL);
+    return NULL;
+}
+
+/* FIX #2: Fiber path releases GVL via run_via_fiber_worker */
+static void retry_delay_sleep(long delay_ms) {
+    if (delay_ms <= 0)
+        return;
+    VALUE scheduler = current_fiber_scheduler();
+    if (scheduler != Qnil) {
+        long remaining = delay_ms;
+        while (remaining > 0) {
+            long chunk = remaining > FIBER_POLL_TIMEOUT_MS ? FIBER_POLL_TIMEOUT_MS : remaining;
+            sleep_arg_t sa = {.delay_ms = chunk};
+            run_via_fiber_worker(scheduler, sleep_without_gvl, &sa);
+            remaining -= chunk;
+        }
+    } else {
+        sleep_arg_t sa = {.delay_ms = delay_ms};
+        rb_thread_call_without_gvl(sleep_without_gvl, &sa, (rb_unblock_function_t *)0, NULL);
+    }
+}
+
+static void parse_options(VALUE options, long *timeout, int *max_conn, retry_config_t *retry_cfg) {
     *timeout = 30;
     *max_conn = 20;
-
+    retry_cfg->max_retries = DEFAULT_RETRIES;
+    retry_cfg->retry_delay_ms = DEFAULT_RETRY_DELAY;
+    retry_cfg->retry_http_codes = NULL;
+    retry_cfg->retry_http_count = 0;
     if (NIL_P(options) || !rb_obj_is_kind_of(options, rb_cHash))
         return;
 
     VALUE t = rb_hash_aref(options, sym_timeout);
     if (!NIL_P(t)) {
-        long timeout_val = NUM2LONG(t);
-        if (timeout_val > MAX_TIMEOUT)
-            timeout_val = MAX_TIMEOUT;
-        else if (timeout_val <= 0)
-            timeout_val = 30;
-        *timeout = timeout_val;
+        long v = NUM2LONG(t);
+        if (v > MAX_TIMEOUT)
+            v = MAX_TIMEOUT;
+        else if (v <= 0)
+            v = 30;
+        *timeout = v;
     }
-
     VALUE c = rb_hash_aref(options, sym_connections);
     if (!NIL_P(c)) {
-        int conn_val = NUM2INT(c);
-        if (conn_val > 100)
-            conn_val = 100;
-        else if (conn_val <= 0)
-            conn_val = 20;
-        *max_conn = conn_val;
+        int v = NUM2INT(c);
+        if (v > 100)
+            v = 100;
+        else if (v <= 0)
+            v = 20;
+        *max_conn = v;
+    }
+    VALUE r = rb_hash_aref(options, sym_retries);
+    if (!NIL_P(r)) {
+        int v = NUM2INT(r);
+        if (v < 0)
+            v = 0;
+        if (v > MAX_RETRIES)
+            v = MAX_RETRIES;
+        retry_cfg->max_retries = v;
+    }
+    VALUE rd = rb_hash_aref(options, sym_retry_delay);
+    if (!NIL_P(rd)) {
+        long v = NUM2LONG(rd);
+        if (v < 0)
+            v = 0;
+        if (v > 30000)
+            v = 30000;
+        retry_cfg->retry_delay_ms = v;
+    }
+    VALUE rc = rb_hash_aref(options, sym_retry_codes);
+    if (!NIL_P(rc) && rb_obj_is_kind_of(rc, rb_cArray)) {
+        int len = (int)RARRAY_LEN(rc);
+        if (len > 0) {
+            retry_cfg->retry_http_codes = malloc(sizeof(int) * len);
+            if (retry_cfg->retry_http_codes) {
+                retry_cfg->retry_http_count = len;
+                for (int i = 0; i < len; i++)
+                    retry_cfg->retry_http_codes[i] = NUM2INT(rb_ary_entry(rc, i));
+            }
+        }
     }
 }
 
-static VALUE internal_execute(VALUE requests, VALUE options, int target, int stream) {
-    Check_Type(requests, T_ARRAY);
-    int count = (int)RARRAY_LEN(requests);
-    if (count == 0)
-        return rb_ary_new();
+typedef struct {
+    multi_session_t *session;
+    int *invalid;
+    retry_config_t *retry_cfg;
+} cleanup_ctx_t;
+
+static VALUE cleanup_session(VALUE arg) {
+    cleanup_ctx_t *ctx = (cleanup_ctx_t *)arg;
+    if (ctx->session->requests) {
+        for (int i = 0; i < ctx->session->count; i++) {
+            if (ctx->session->requests[i].easy)
+                curl_multi_remove_handle(ctx->session->multi, ctx->session->requests[i].easy);
+            request_ctx_free(&ctx->session->requests[i]);
+        }
+        free(ctx->session->requests);
+        ctx->session->requests = NULL;
+    }
+    if (ctx->invalid) {
+        free(ctx->invalid);
+        ctx->invalid = NULL;
+    }
+    if (ctx->session->multi) {
+        curl_multi_cleanup(ctx->session->multi);
+        ctx->session->multi = NULL;
+    }
+    if (ctx->retry_cfg && ctx->retry_cfg->retry_http_codes) {
+        free(ctx->retry_cfg->retry_http_codes);
+        ctx->retry_cfg->retry_http_codes = NULL;
+    }
+    return Qnil;
+}
 
+typedef struct {
+    VALUE requests;
+    VALUE options;
+    int target;
+    int stream;
+    multi_session_t *session;
+    int *invalid;
+    retry_config_t *retry_cfg;
     long timeout_sec;
-    int max_conn;
-    parse_options(options, &timeout_sec, &max_conn);
+} execute_args_t;
 
-    multi_session_t session;
-    session.multi = curl_multi_init();
-    session.count = count;
-    session.timeout_ms = timeout_sec * 1000;
-    session.max_connections = max_conn;
-
-    curl_multi_setopt(session.multi, CURLMOPT_MAXCONNECTS, (long)max_conn);
-    curl_multi_setopt(session.multi, CURLMOPT_MAX_TOTAL_CONNECTIONS, (long)max_conn);
-#ifdef CURLPIPE_MULTIPLEX
-    curl_multi_setopt(session.multi, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
-#endif
-
-    session.requests = calloc(count, sizeof(request_ctx_t));
-    if (!session.requests) {
-        curl_multi_cleanup(session.multi);
-        rb_raise(rb_eNoMemError, "failed to allocate request contexts");
-    }
+static VALUE internal_execute_body(VALUE arg) {
+    execute_args_t *ea = (execute_args_t *)arg;
+    VALUE requests = ea->requests;
+    multi_session_t *session = ea->session;
+    int *invalid = ea->invalid;
+    retry_config_t *retry_cfg = ea->retry_cfg;
+    long timeout_sec = ea->timeout_sec;
+    int count = session->count, target = ea->target, stream = ea->stream;
 
     int valid_requests = 0;
     for (int i = 0; i < count; i++) {
         VALUE req = rb_ary_entry(requests, i);
-        request_ctx_init(&session.requests[i], i);
-
-        if (!setup_easy_handle(&session.requests[i], req, timeout_sec)) {
-            session.requests[i].done = 1;
+        request_ctx_init(&session->requests[i], i);
+        if (!setup_easy_handle(&session->requests[i], req, timeout_sec)) {
+            session->requests[i].done = 1;
+            invalid[i] = 1;
             continue;
         }
-
-        CURLMcode mc = curl_multi_add_handle(session.multi, session.requests[i].easy);
+        CURLMcode mc = curl_multi_add_handle(session->multi, session->requests[i].easy);
         if (mc != CURLM_OK) {
-            session.requests[i].done = 1;
+            session->requests[i].done = 1;
+            invalid[i] = 1;
             continue;
         }
-
         valid_requests++;
     }
-
     if (valid_requests == 0)
-        session.still_running = 0;
+        session->still_running = 0;
 
     completion_ctx_t cctx;
     cctx.results = stream ? Qnil : rb_ary_new2(count);
     cctx.completed = 0;
     cctx.target = target;
     cctx.stream = stream;
-
     if (!stream) {
         for (int i = 0; i < count; i++)
             rb_ary_store(cctx.results, i, Qnil);
     }
 
-    if (has_fiber_scheduler()) {
-        for (;;) {
-            CURLMcode mc = curl_multi_perform(session.multi, &session.still_running);
-            if (mc != CURLM_OK)
+    run_multi_loop(session, &cctx);
+
+    if (!stream && retry_cfg->max_retries > 0) {
+        int prev_all_failed = 0;
+        for (int attempt = 0; attempt < retry_cfg->max_retries; attempt++) {
+            int retry_count = 0;
+            int *ri = malloc(sizeof(int) * count);
+            if (!ri)
                 break;
-            if (process_completed(&session, &cctx))
+            for (int i = 0; i < count; i++) {
+                if (invalid[i] || !session->requests[i].done)
+                    continue;
+                if (should_retry(&session->requests[i], retry_cfg))
+                    ri[retry_count++] = i;
+            }
+            if (retry_count == 0) {
+                free(ri);
                 break;
-            if (session.still_running == 0)
+            }
+            int done_count = 0;
+            for (int i = 0; i < count; i++)
+                if (!invalid[i] && session->requests[i].done)
+                    done_count++;
+            int all_failed = (retry_count == done_count);
+            if (all_failed && prev_all_failed) {
+                free(ri);
                 break;
-
-            int numfds = 0;
-            curl_multi_poll(session.multi, NULL, 0, FIBER_POLL_TIMEOUT_MS, &numfds);
-            rb_thread_schedule();
-        }
-        process_completed(&session, &cctx);
-    } else {
-        if (stream || target > 0) {
-            curl_multi_perform(session.multi, &session.still_running);
-            while (session.still_running > 0) {
-                rb_thread_call_without_gvl(poll_without_gvl, &session, unblock_perform, &session);
-                if (process_completed(&session, &cctx))
-                    break;
             }
-            process_completed(&session, &cctx);
-        } else {
-            session.still_running = 1;
-            curl_multi_perform(session.multi, &session.still_running);
-            rb_thread_call_without_gvl(perform_without_gvl, &session, unblock_perform, &session);
-            process_completed(&session, &cctx);
+            prev_all_failed = all_failed;
+            retry_delay_sleep(retry_cfg->retry_delay_ms);
+            for (int r = 0; r < retry_count; r++) {
+                int idx = ri[r];
+                request_ctx_t *rc = &session->requests[idx];
+                curl_multi_remove_handle(session->multi, rc->easy);
+                if (!request_ctx_reset_for_retry(rc)) {
+                    rc->done = 1;
+                    invalid[idx] = 1;
+                    continue;
+                }
+                VALUE req = rb_ary_entry(requests, idx);
+                if (!setup_easy_handle(rc, req, timeout_sec)) {
+                    rc->done = 1;
+                    invalid[idx] = 1;
+                    continue;
+                }
+                CURLMcode mc = curl_multi_add_handle(session->multi, rc->easy);
+                if (mc != CURLM_OK) {
+                    rc->done = 1;
+                    invalid[idx] = 1;
+                }
+            }
+            free(ri);
+            cctx.completed = 0;
+            run_multi_loop(session, &cctx);
         }
     }
 
     if (!stream) {
         for (int i = 0; i < count; i++) {
-            if (session.requests[i].done && rb_ary_entry(cctx.results, i) == Qnil) {
-                VALUE error_response = build_error_response("Invalid request configuration");
-                VALUE pair = rb_ary_new_from_args(2, INT2NUM(i), error_response);
-                rb_ary_store(cctx.results, i, pair);
+            request_ctx_t *rc = &session->requests[i];
+            VALUE response;
+            if (invalid[i]) {
+                response = build_error_response("Invalid request configuration");
+            } else if (rc->curl_result == CURLE_OK) {
+                response = build_response(rc);
+            } else {
+                response = build_error_response_with_code(curl_easy_strerror(rc->curl_result),
+                                                          (int)rc->curl_result);
             }
+            rb_ary_store(cctx.results, i, rb_ary_new_from_args(2, INT2NUM(i), response));
         }
     }
+    return stream ? Qnil : cctx.results;
+}
 
-    for (int i = 0; i < count; i++) {
-        curl_multi_remove_handle(session.multi, session.requests[i].easy);
-        request_ctx_free(&session.requests[i]);
+static VALUE internal_execute(VALUE requests, VALUE options, int target, int stream) {
+    Check_Type(requests, T_ARRAY);
+
+    long count_long = RARRAY_LEN(requests);
+    if (count_long == 0)
+        return rb_ary_new();
+    if (count_long > MAX_REQUESTS)
+        rb_raise(rb_eArgError, "too many requests (%ld), maximum is %d", count_long, MAX_REQUESTS);
+    if (count_long > INT_MAX)
+        rb_raise(rb_eArgError, "request count overflows int");
+    int count = (int)count_long;
+
+    long timeout_sec;
+    int max_conn;
+    retry_config_t retry_cfg;
+    parse_options(options, &timeout_sec, &max_conn, &retry_cfg);
+
+    if (stream || target > 0) {
+        if (retry_cfg.max_retries > 0 && stream)
+            rb_warn("FastCurl: retries are not supported in stream_execute, ignoring "
+                    "retries option");
+        if (retry_cfg.max_retries > 0 && target > 0)
+            rb_warn("FastCurl: retries are not supported in first_execute, ignoring "
+                    "retries option");
+        retry_cfg.max_retries = 0;
     }
-    free(session.requests);
-    curl_multi_cleanup(session.multi);
 
-    return stream ? Qnil : cctx.results;
+    multi_session_t session;
+    session.multi = curl_multi_init();
+    session.count = count;
+    session.timeout_ms = timeout_sec * 1000;
+    session.max_connections = max_conn;
+    session.cancelled = 0;
+    session.requests = NULL;
+
+    curl_multi_setopt(session.multi, CURLMOPT_MAXCONNECTS, (long)max_conn);
+    curl_multi_setopt(session.multi, CURLMOPT_MAX_TOTAL_CONNECTIONS, (long)max_conn);
+#ifdef CURLPIPE_MULTIPLEX
+    curl_multi_setopt(session.multi, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
+#endif
+
+    session.requests = calloc(count, sizeof(request_ctx_t));
+    if (!session.requests) {
+        curl_multi_cleanup(session.multi);
+        if (retry_cfg.retry_http_codes)
+            free(retry_cfg.retry_http_codes);
+        rb_raise(rb_eNoMemError, "failed to allocate request contexts");
+    }
+
+    int *invalid = calloc(count, sizeof(int));
+    if (!invalid) {
+        free(session.requests);
+        curl_multi_cleanup(session.multi);
+        if (retry_cfg.retry_http_codes)
+            free(retry_cfg.retry_http_codes);
+        rb_raise(rb_eNoMemError, "failed to allocate tracking array");
+    }
+
+    cleanup_ctx_t cleanup = {.session = &session, .invalid = invalid, .retry_cfg = &retry_cfg};
+    execute_args_t ea = {
+        .requests = requests,
+        .options = options,
+        .target = target,
+        .stream = stream,
+        .session = &session,
+        .invalid = invalid,
+        .retry_cfg = &retry_cfg,
+        .timeout_sec = timeout_sec,
+    };
+    return rb_ensure(internal_execute_body, (VALUE)&ea, cleanup_session, (VALUE)&cleanup);
 }
 
 static VALUE rb_fast_curl_execute(int argc, VALUE *argv, VALUE self) {
@@ -656,24 +903,20 @@ static VALUE rb_fast_curl_execute(int argc, VALUE *argv, VALUE self) {
 static VALUE rb_fast_curl_first_execute(int argc, VALUE *argv, VALUE self) {
     VALUE requests, options;
     rb_scan_args(argc, argv, "1:", &requests, &options);
-
     int count = 1;
     if (!NIL_P(options)) {
         VALUE c = rb_hash_aref(options, sym_count);
         if (!NIL_P(c))
             count = NUM2INT(c);
     }
-
     return internal_execute(requests, options, count, 0);
 }
 
 static VALUE rb_fast_curl_stream_execute(int argc, VALUE *argv, VALUE self) {
     VALUE requests, options;
     rb_scan_args(argc, argv, "1:", &requests, &options);
-
     if (!rb_block_given_p())
         rb_raise(rb_eArgError, "stream_execute requires a block");
-
     return internal_execute(requests, options, -1, 1);
 }
 
@@ -690,6 +933,9 @@ void Init_fast_curl(void) {
     id_connections = rb_intern("connections");
     id_count = rb_intern("count");
     id_keys = rb_intern("keys");
+    id_retries = rb_intern("retries");
+    id_retry_delay = rb_intern("retry_delay");
+    id_retry_codes = rb_intern("retry_codes");
 
     sym_status = ID2SYM(id_status);
     rb_gc_register_address(&sym_status);
@@ -709,6 +955,12 @@ void Init_fast_curl(void) {
     rb_gc_register_address(&sym_connections);
     sym_count = ID2SYM(id_count);
     rb_gc_register_address(&sym_count);
+    sym_retries = ID2SYM(id_retries);
+    rb_gc_register_address(&sym_retries);
+    sym_retry_delay = ID2SYM(id_retry_delay);
+    rb_gc_register_address(&sym_retry_delay);
+    sym_retry_codes = ID2SYM(id_retry_codes);
+    rb_gc_register_address(&sym_retry_codes);
 
     VALUE mFastCurl = rb_define_module("FastCurl");
 

data/lib/fast_curl/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FastCurl
-  VERSION = "0.1.1"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fast_curl
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - roman-haidarov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-24 00:00:00.000000000 Z
+date: 2026-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -96,7 +96,8 @@ dependencies:
         version: '1.8'
 description: Parallel HTTP requests via libcurl curl_multi API. Releases GVL during
   I/O, compatible with Async gem and Fiber scheduler. Supports execute (all), first_execute
-  (first N), stream_execute (yield as ready).
+  (first N), stream_execute (yield as ready). Built-in retry functionality for network
+  errors and custom HTTP status codes.
 email:
 - roman.haidarov@gmail.com
 executables: []
@@ -122,7 +123,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="