rage-iodine 5.5.0 → 5.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce6be54873c53f93352aa7c739c74e73f5510eaeaab015bd2afc5e0fe261ff38
-  data.tar.gz: 45bba38d8c14f66e780981c13a05a7ca1d036a6809f71f33833e8743e285c32b
+  metadata.gz: 7ffa46cab7e0fb7fc7550dd142f42b0850287fee60cc0d72b7f52757f52720f7
+  data.tar.gz: c51b8ad9e316c21ed06e6803dcfb5af7bf70fc3eee84a0fd179b2730d2572473
 SHA512:
-  metadata.gz: be4a8fd787b970fb21e30d6ec21e590ca27da1122d62f7efeac532f5b2fffd920c7016d489bd5c1e748e9d559058c23c3f567edc0e99e1da34a4a81b2bdde70c
-  data.tar.gz: 25e51f20a4a572caab13708ca5496e73cbcbb90810c13bf1000d8cbb0a1ec75bf797ade820d756a2c30237ac37c254e89303d0adeb7b6f060133a6cc1edc708e
+  metadata.gz: fa99ee4e7abb10b55b6f14aeeaef6bf03e85cf8aff9b33a66f7b4f64097c5ef824e0c3de6663caf00f5404b2d08b663debb60c796a0a44490138a96ac92a832c
+  data.tar.gz: ca2a4ac6f633955b202dccf09661cb7799ae92e16078ef3776c1648e18e2b1ab620f470f4b99b3c75b7d0e8f9b064fad180fd5c9b32ab6ae0ddd60c9d601b58d

data/CHANGELOG.md

@@ -6,6 +6,10 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.5.6.0 (2026-09-06)
+
+**Update**: TCP Socket Listen: Accept Queue
+
 #### Change log v.5.5.0 (2026-07-06)
 
 **Update**: Update `pre_start` callbacks to fail the server launch in case of errors

data/Gemfile

@@ -4,7 +4,8 @@ group :test do
   gem 'pry'
   gem 'rspec'
   gem 'rack'
-  gem 'http'
+  gem 'http', '~> 5.0'
+  gem 'ostruct', '~> 0.6.3'
   gem 'base64'
   gem 'benchmark'
 end

data/ext/iodine/fio.c

@@ -4532,10 +4532,22 @@ Initialize the library
 
 static void fio_pubsub_on_fork(void);
 
+#if defined(__linux__)
+/* accept-queue tracking lock for the listener registry (defined alongside
+ * fio_accept_queue_listeners in the listener section below); declared here
+ * so fio_on_fork can reset it across children. */
+static fio_lock_i fio_accept_queue_lock;
+#endif
+
 /* Called within a child process after it starts. */
 static void fio_on_fork(void) {
   fio_timer_lock = FIO_LOCK_INIT;
   fio_data->lock = FIO_LOCK_INIT;
+#if defined(__linux__)
+  /* a forked child may inherit the accept-queue lock while a parent thread
+   * held it mid-walk; that thread won't exist in the child, so reset it. */
+  fio_accept_queue_lock = FIO_LOCK_INIT;
+#endif
   fio_defer_on_fork();
   fio_malloc_after_fork();
   fio_poll_init();
@@ -5571,6 +5583,14 @@ The listening protocol (use the facil.io API to make a socket and attach it)
 typedef struct {
   fio_protocol_s pr;
   intptr_t uuid;
+#if defined(__linux__)
+/**
+* Listener node adding this listener into to fio_accept_queue_listeners,
+* so Iodine::Perf.queued_connections can find its socket's fd and read its
+* kernel length accept-queue(AcceptQ):backlog where (backlog <= somaxconn) (TCP_INFO).
+*/
+  fio_ls_embd_s listener_node;
+#endif
   void *udata;
   void (*on_open)(intptr_t uuid, void *udata);
   void (*on_start)(intptr_t uuid, void *udata);
@@ -5582,8 +5602,20 @@ typedef struct {
   void *tls;
 } fio_listen_protocol_s;
 
+#if defined(__linux__)
+/* tracks iodine's listening sockets for the accept-queue backlog query.
+ * guarded against concurrent teardown (reactor thread, no GVL) */
+static fio_ls_embd_s fio_accept_queue_listeners = FIO_LS_INIT(fio_accept_queue_listeners);
+static fio_lock_i fio_accept_queue_lock = FIO_LOCK_INIT;
+#endif
+
 static void fio_listen_cleanup_task(void *pr_) {
   fio_listen_protocol_s *pr = pr_;
+#if defined(__linux__)
+  fio_lock(&fio_accept_queue_lock);
+  fio_ls_embd_remove(&pr->listener_node);
+  fio_unlock(&fio_accept_queue_lock);
+#endif
 #ifndef __MINGW32__
   if (pr->tls)
     fio_tls_destroy(pr->tls);
@@ -5733,6 +5765,12 @@ intptr_t fio_listen FIO_IGNORE_MACRO(struct fio_listen_args args) {
   if (port_len)
     memcpy(pr->port, args.port, port_len + 1);
 
+#if defined(__linux__)
+  fio_lock(&fio_accept_queue_lock);
+  fio_ls_embd_push(&fio_accept_queue_listeners, &pr->listener_node);
+  fio_unlock(&fio_accept_queue_lock);
+#endif
+
   if (fio_is_running()) {
     fio_attach(pr->uuid, &pr->pr);
   } else {
@@ -5753,6 +5791,65 @@ error:
   return -1;
 }
 
+/* -------------------------------------------------------------------------
+ * Kernel accept-queue(AcceptQ) which is Queue length: backlog, where backlog <= somaxconn  
+ * "backlog are established connections waiting for accept()" = sk_ack_backlog.
+ * Returns the sum of the accept-queues of all iodine listening sockets, or 0.
+ * ---------------------------------------------------------------------- */
+#if defined(__linux__)
+intptr_t fio_queued_connections(void) {
+  intptr_t backlog = 0;
+
+  fio_lock(&fio_accept_queue_lock);
+  /**
+   * Walk every registered listener and sum its kernel accept-queue depth/length.
+   * The list always begins with a permanent head node (fio_accept_queue_listeners) 
+   * that works like a fixed bookmark: it holds no listener of its own, real nodes 
+   * are chained after it, and the last node links back to it, forming a circle 
+   * i.e a circular linked list also it's a doubly linked list.
+   *
+   * So the loop:
+   *   - starts at `.next`, i.e. the FIRST REAL node starting at the head
+   *     itself would be wrong, since it owns no listener and converting it
+   *     with FIO_LS_EMBD_OBJ would produce a bogus pointer;
+   *   - stops when it arrives back at the head, meaning every real node
+   *     has been visited;
+   *   - runs zero times on an empty list, because a lone head simply
+   *     points at itself.
+   */
+  for (fio_ls_embd_s *pos = fio_accept_queue_listeners.next; pos != &fio_accept_queue_listeners; pos = pos->next) {
+    fio_listen_protocol_s *pr = FIO_LS_EMBD_OBJ(fio_listen_protocol_s, listener_node, pos);
+    struct tcp_info info;
+    socklen_t tlen = sizeof(info);
+    int fd = fio_uuid2fd(pr->uuid);
+
+    fio_lock(&fd_data(fd).protocol_lock);
+
+    /* Skip sockets that were closed or reused before we could query them.
+     * Callers must run this after listeners are attached (e.g. from within
+     * Iodine.run / a background thread), so the listener's protocol slot is
+     * populated and the checks below are meaningful. */
+    if (!uuid_is_valid(pr->uuid) || fd_data(fd).protocol != &pr->pr) {
+      fio_unlock(&fd_data(fd).protocol_lock);
+      continue;
+    }
+
+    int ok = !getsockopt(fd, IPPROTO_TCP, TCP_INFO, &info, &tlen);
+
+    fio_unlock(&fd_data(fd).protocol_lock);
+
+    if (!ok) {
+      continue;
+    }
+
+    backlog += (intptr_t)info.tcpi_unacked;
+  }
+  fio_unlock(&fio_accept_queue_lock);
+
+  return backlog;
+}
+#endif
+
 /* *****************************************************************************
 Section Start Marker
 

data/ext/iodine/fio.h

@@ -1111,6 +1111,19 @@ intptr_t fio_socket(const char *address, const char *port, uint8_t is_server);
  */
 intptr_t fio_accept(intptr_t srv_uuid);
 
+/**
+ * Returns the number of established connections currently parked in the
+ * kernel's accept queue(s) (sk_ack_backlog) of all iodine listening sockets.
+ *
+ * The query goes straight to the kernel via getsockopt(TCP_INFO).
+ *
+ * Returns the total accept queue length across all iodine listeners, or 0
+ * when there are no listeners.
+ */
+#if defined(__linux__)
+intptr_t fio_queued_connections(void);
+#endif /* linux only */
+
 /**
  * Returns 1 if the uuid refers to a valid and open, socket.
  *

data/ext/iodine/iodine.c

@@ -1401,6 +1401,9 @@ void Init_iodine_ext(void) {
   // initialize concurrency related methods
   iodine_defer_initialize();
 
+  // initialize performance metrics
+  iodine_perf_initialize();
+
   // initialize the connection class
   iodine_connection_init();
 

data/ext/iodine/iodine.h

@@ -42,6 +42,7 @@ typedef struct {
 #include "iodine_http.h"
 #include "iodine_json.h"
 #include "iodine_mustache.h"
+#include "iodine_perf.h"
 #include "iodine_pubsub.h"
 #include "iodine_rack_io.h"
 #include "iodine_store.h"

data/ext/iodine/iodine_defer.c

@@ -415,6 +415,7 @@ static void iodine_defer_on_finish(void *ignr) {
   iodine_join_io_thread();
 }
 
+
 /* *****************************************************************************
 Add defer API to Iodine
 ***************************************************************************** */

data/ext/iodine/iodine_perf.c

@@ -0,0 +1,28 @@
+#include "iodine.h"
+
+/* *****************************************************************************
+Performance metrics
+***************************************************************************** */
+
+/**
+ * Iodine::Perf.queued_connections
+ *
+ * Returns the total number of established connections currently parked in
+ * the kernel's accept queue(s) (sk_ack_backlog) for all iodine listening
+ * sockets. Returns 0 when there are no listeners and nil on non-Linux systems.
+ */
+static VALUE iodine_perf_queued_connections(VALUE self) {
+  (void)self;
+#if defined(__linux__)
+  intptr_t backlog = fio_queued_connections();
+  return INT2NUM((long)backlog);
+#else
+  return Qnil;
+#endif
+}
+
+void iodine_perf_initialize(void) {
+  VALUE IodinePerfModule = rb_define_module_under(IodineModule, "Perf");
+  rb_define_module_function(IodinePerfModule, "queued_connections",
+                            iodine_perf_queued_connections, 0);
+}

data/ext/iodine/iodine_perf.h

@@ -0,0 +1,6 @@
+#ifndef H_IODINE_PERF_H
+#define H_IODINE_PERF_H
+
+void iodine_perf_initialize(void);
+
+#endif

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '5.5.0'.freeze
+  VERSION = '5.6.0'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rage-iodine
 version: !ruby/object:Gem::Version
-  version: 5.5.0
+  version: 5.6.0
 platform: ruby
 authors:
 - Boaz Segev
@@ -217,6 +217,8 @@ files:
 - ext/iodine/iodine_json.h
 - ext/iodine/iodine_mustache.c
 - ext/iodine/iodine_mustache.h
+- ext/iodine/iodine_perf.c
+- ext/iodine/iodine_perf.h
 - ext/iodine/iodine_pubsub.c
 - ext/iodine/iodine_pubsub.h
 - ext/iodine/iodine_rack_io.c