io-metrics 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ff485ebbe44dc9bae2117fa771ed89e7b2e42e3270d93094bae2fa4808405a5d
+  data.tar.gz: e724a731428b1c7d5219f6abcb518b99cddd572efcf0d9de02eff1d30f90400e
+SHA512:
+  metadata.gz: 27ef4c0c0f75b3933bbd7cf6815997bf62d3d3cc05c6dbe0ca9e75a3db143f6fb122153d4d7b967fd2b04781b0c12dc1158a7998178cee6bc954d7c7e576a3b6
+  data.tar.gz: c1bfed9052fb9fbf92f25bf9952eb83d3dc0759bb55746cca68068942d772a145c43659888045315b58ba9b7c4b4209ce196889b21d0c0d17c4b7cd6cacff5b4

data/lib/io/metrics/listener/darwin.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+class IO
+	module Metrics
+		# Darwin (macOS) implementation of listener statistics using netstat -L.
+		class Listener::Darwin
+			NETSTAT = "/usr/sbin/netstat"
+			
+			# Whether listener listeners can be captured on this system.
+			def self.supported?
+				File.executable?(NETSTAT)
+			end
+			
+			# Parse an address from netstat format to "ip:port" format.
+			# @parameter address [String] Address string from netstat, e.g. "127.0.0.1.50876" or "*.63703".
+			# @returns [String] Address in "ip:port" format, e.g. "127.0.0.1:50876" or "0.0.0.0:63703".
+			def self.parse_address(address)
+				# Handle wildcard addresses: *.port -> 0.0.0.0:port
+				if address.start_with?("*.")
+					port = address[2..-1]
+					return "0.0.0.0:#{port}"
+				end
+				
+				# Handle IPv4 addresses: ip.port -> ip:port
+				if address =~ /^([0-9.]+)\.(\d+)$/
+					ip = $1
+					port = $2
+					return "#{ip}:#{port}"
+				end
+				
+				# Handle IPv6 addresses (if present in future)
+				# For now, return as-is
+				return address
+			end
+			
+			# Parse netstat -L output and extract listener statistics.
+			# @parameter addresses [Array(String) | Nil] Optional filter for specific addresses.
+			# @returns [Hash(String, Listener)] Hash mapping "ip:port" to Listener.
+			def self.capture_tcp(addresses = nil)
+				listeners = {}
+				address_filter = addresses ? addresses.map{|address| address.downcase}.to_set : nil
+				
+				IO.popen([NETSTAT, "-L", "-an", "-p", "tcp"], "r") do |io|
+					# Skip header lines
+					io.each_line do |line|
+						# Skip header and empty lines
+						next if line.start_with?("Current") || line.start_with?("Listen") || line.strip.empty?
+						
+						# Format: "queue_length/incomplete_queue_length/maximum_queue_length    Local Address"
+						fields = line.split(/\s+/)
+						next if fields.size < 2
+						
+						queue_statistics = fields[0]
+						local_address_raw = fields[1]
+						
+						# Parse queue statistics: "queue_length/incomplete_queue_length/maximum_queue_length"
+						if queue_statistics =~ /^(\d+)\/(\d+)\/(\d+)$/
+							queue_length = $1.to_i
+							# incomplete_queue_length = $2.to_i  # incomplete connections (SYN_RECV)
+							# maximum_queue_length = $3.to_i  # maximum queue size
+							
+							# Parse address
+							address = parse_address(local_address_raw)
+							
+							# Apply filter if specified
+							next if address_filter && !address_filter.include?(address)
+							
+							listeners[address] ||= Listener.zero
+							listeners[address].queue_size = queue_length
+							# active_connections set to 0 (can't reliably count per listener)
+							listeners[address].active_connections = 0
+						end
+					end
+				end
+				
+				return listeners
+			rescue Errno::ENOENT, Errno::EACCES
+				return {}
+			end
+			
+			# Capture listener listeners for TCP sockets.
+			# @parameter addresses [Array(String) | Nil] TCP address(es) to capture, e.g. ["0.0.0.0:80"]. If nil, captures all.
+			# @parameter paths [Array(String) | Nil] Unix socket path(s) to capture (not supported on Darwin).
+			# @returns [Hash(String, Listener)] Hash mapping addresses to Listener.
+			def self.capture(addresses: nil, paths: nil)
+				listeners = {}
+				
+				# Capture TCP listeners (Unix sockets not supported on Darwin via netstat)
+				listeners.merge!(capture_tcp(addresses))
+				
+				return listeners
+			end
+		end
+	end
+end
+
+# Wire Listener.capture and Listener.supported? to this implementation on Darwin.
+if IO::Metrics::Listener::Darwin.supported?
+	class << IO::Metrics::Listener
+		# Whether listener capture is supported on this platform.
+		# @returns [Boolean] True if netstat is executable.
+		def supported?
+			true
+		end
+		
+		# Capture listener listeners for the given address(es).
+		# @parameter addresses [Array(String) | Nil] TCP address(es) to capture, e.g. ["0.0.0.0:80"]. If nil, captures all listening TCP sockets.
+		# @parameter paths [Array(String) | Nil] Unix socket path(s) to capture (not supported on Darwin).
+		# @returns [Hash(String, Listener) | Nil] A hash mapping addresses to Listener, or nil if not supported.
+		def capture(**options)
+			IO::Metrics::Listener::Darwin.capture(**options)
+		end
+	end
+end

data/lib/io/metrics/listener/linux.rb

@@ -0,0 +1,325 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "set"
+require "ipaddr"
+
+class IO
+	module Metrics
+		# Linux implementation of listener statistics using /proc/net/tcp, /proc/net/tcp6, and /proc/net/unix.
+		class Listener::Linux
+			# TCP socket states (from include/net/tcp_states.h)
+			TCP_ESTABLISHED = 0x01
+			TCP_SYN_SENT = 0x02
+			TCP_SYN_RECV = 0x03
+			TCP_FIN_WAIT1 = 0x04
+			TCP_FIN_WAIT2 = 0x05
+			TCP_TIME_WAIT = 0x06
+			TCP_CLOSE = 0x07
+			TCP_CLOSE_WAIT = 0x08
+			TCP_LAST_ACK = 0x09
+			TCP_LISTEN = 0x0A
+			TCP_CLOSING = 0x0B
+			
+			# Unix socket states (from include/uapi/linux/net.h)
+			SS_UNCONNECTED = 0x01
+			SS_CONNECTING = 0x02
+			SS_CONNECTED = 0x03
+			
+			# Regex pattern for parsing /proc/net/tcp and /proc/net/tcp6 lines.
+			# Captures: local_ip, local_port, remote_ip, remote_port, state, tx_queue, rx_queue
+			TCP_LINE_PATTERN = /\A\s*\d+:\s+([0-9A-Fa-f]+):([0-9A-Fa-f]+)\s+([0-9A-Fa-f]+):([0-9A-Fa-f]+)\s+([0-9A-Fa-f]+)\s+([0-9A-Fa-f]+):([0-9A-Fa-f]+)/
+			
+			# Whether listener listeners can be captured on this system.
+			def self.supported?
+				File.readable?("/proc/net/tcp")
+			end
+			
+			# Parse an IPv4 address from /proc/net/tcp format (hex, little-endian).
+			# @parameter hex [String] Hexadecimal address string, e.g. "0100007F" for 127.0.0.1.
+			# @returns [String] IP address in dotted decimal format, e.g. "127.0.0.1".
+			def self.parse_ipv4(hex)
+				raise ArgumentError, "Invalid IPv4 hex format: #{hex.inspect}" unless hex =~ /\A[0-9A-Fa-f]{8}\z/
+				
+				# Each byte is 2 hex chars, read in reverse order (little-endian)
+				bytes = hex.scan(/../).reverse.map{|byte| byte.to_i(16)}
+				bytes.join(".")
+			end
+			
+			# Parse an IPv6 address from /proc/net/tcp6 format (hex, little-endian).
+			# @parameter hex [String] Hexadecimal address string, 32 hex chars (16 bytes).
+			# @returns [String] IP address in compressed IPv6 format, e.g. "::1" or "2001:db8::1".
+			def self.parse_ipv6(hex)
+				raise ArgumentError, "Invalid IPv6 hex format: #{hex.inspect}" unless hex =~ /\A[0-9A-Fa-f]{32}\z/
+				
+				# IPv6 is 16 bytes (32 hex chars) stored as 4-byte words in little-endian format
+				# Split into 4-byte words (8 hex chars each) and reverse bytes within each word
+				words = hex.scan(/.{8}/)
+				
+				reversed_words = words.map do |word|
+					word.scan(/../).reverse.join("")
+				end
+				
+				# Convert to 16-bit segments and create colon-separated format
+				segments = reversed_words.flat_map do |word|
+					[word[0..3], word[4..7]]
+				end
+				
+				ipv6_expanded = segments.join(":")
+				
+				# Use IPAddr to compress the address
+				IPAddr.new(ipv6_expanded).to_s
+			end
+			
+			# Parse a port from /proc/net/tcp format (hex).
+			# @parameter hex [String] Hexadecimal port string, e.g. "0050" for port 80.
+			# @returns [Integer] Port number.
+			def self.parse_port(hex)
+				hex.to_i(16)
+			end
+			
+			# Parse a socket state from /proc/net/tcp format.
+			# @parameter hex [String] Hexadecimal state string.
+			# @returns [Symbol] Socket state (:listen, :established, etc.)
+			def self.parse_state(hex)
+				state = hex.to_i(16)
+				case state
+				when TCP_LISTEN then :listen
+				when TCP_ESTABLISHED then :established
+				when TCP_SYN_SENT then :syn_sent
+				when TCP_SYN_RECV then :syn_recv
+				when TCP_FIN_WAIT1 then :fin_wait1
+				when TCP_FIN_WAIT2 then :fin_wait2
+				when TCP_TIME_WAIT then :time_wait
+				when TCP_CLOSE then :close
+				when TCP_CLOSE_WAIT then :close_wait
+				when TCP_LAST_ACK then :last_ack
+				when TCP_CLOSING then :closing
+				else :unknown
+				end
+			end
+			
+			# Find the best matching listener for an ESTABLISHED connection.
+			# @parameter local_address [String] Local address in "ip:port" or "[ipv6]:port" format.
+			# @parameter listeners [Hash(String, Listener)] Hash of listener addresses to Listener objects.
+			# @returns [String | Nil] The address of the matching listener, or nil if no match.
+			def self.find_matching_listener(local_address, listeners)
+				# Try exact match first
+				return local_address if listeners.key?(local_address)
+				
+				# Parse the address to extract IP and port
+				if local_address.start_with?("[")
+					# IPv6 format: [::1]:port
+					if match = local_address.match(/\A\[(.+)\]:(\d+)\z/)
+						local_ip = $1
+						local_port = $2
+					else
+						return nil
+					end
+				else
+					# IPv4 format: 127.0.0.1:port
+					local_ip, local_port = local_address.split(":", 2)
+					return nil unless local_port
+				end
+				
+				# Determine address type using IPAddr for robust detection
+				begin
+					ip_address = IPAddr.new(local_ip)
+					
+					if ip_address.ipv4?
+						# Try IPv4 wildcard match (0.0.0.0:port)
+						wildcard_address = "0.0.0.0:#{local_port}"
+						return wildcard_address if listeners.key?(wildcard_address)
+					else
+						# Try IPv6 wildcard match ([::]:port)
+						wildcard_address = "[::]:#{local_port}"
+						return wildcard_address if listeners.key?(wildcard_address)
+					end
+				rescue IPAddr::InvalidAddressError
+					# If IP parsing fails, return nil
+					return nil
+				end
+				
+				return nil
+			end
+			
+			# Parse /proc/net/tcp or /proc/net/tcp6 and extract listener statistics (optimized single-pass).
+			# @parameter file [String] Path to /proc/net/tcp or /proc/net/tcp6.
+			# @parameter addresses [Array(String) | Nil] Optional filter for specific addresses.
+			# @parameter ipv6 [Boolean] Whether parsing IPv6 addresses.
+			# @returns [Hash(String, Listener)] Hash mapping "ip:port" or "[ipv6]:port" to Listener.
+			def self.capture_tcp_file(file, addresses = nil, ipv6: false)
+				listeners = {}
+				address_filter = addresses ? addresses.map{|address| address.downcase}.to_set : nil
+				connections = []
+				
+				# Single pass: collect LISTEN sockets and ESTABLISHED connections
+				File.foreach(file) do |line|
+					next if line.start_with?("sl")
+					
+					if match = TCP_LINE_PATTERN.match(line)
+						local_ip_hex = match[1]
+						local_port_hex = match[2]
+						remote_ip_hex = match[3]
+						remote_port_hex = match[4]
+						state_hex = match[5]
+						tx_queue_hex = match[6]
+						rx_queue_hex = match[7]
+						
+						state = parse_state(state_hex)
+						
+						# Process LISTEN sockets
+						if state == :listen
+							if ipv6
+								local_ip = parse_ipv6(local_ip_hex)
+								local_address = "[#{local_ip}]:#{parse_port(local_port_hex)}"
+							else
+								local_ip = parse_ipv4(local_ip_hex)
+								local_port = parse_port(local_port_hex)
+								local_address = "#{local_ip}:#{local_port}"
+							end
+							
+							# Apply filter if specified
+							next if address_filter && !address_filter.include?(local_address)
+							
+							listeners[local_address] ||= Listener.zero
+							# rx_queue shows number of connections waiting to be accepted
+							listeners[local_address].queue_size = rx_queue_hex.to_i(16)
+							listeners[local_address].active_connections = 0
+						# Collect ESTABLISHED connections to count later
+						elsif state == :established
+							if ipv6
+								local_ip = parse_ipv6(local_ip_hex)
+								local_address = "[#{local_ip}]:#{parse_port(local_port_hex)}"
+							else
+								local_ip = parse_ipv4(local_ip_hex)
+								local_port = parse_port(local_port_hex)
+								local_address = "#{local_ip}:#{local_port}"
+							end
+							connections << local_address
+						end
+					end
+				end
+				
+				# Count ESTABLISHED connections for each listener
+				connections.each do |local_address|
+					if listener_address = find_matching_listener(local_address, listeners)
+						listeners[listener_address].active_connections += 1
+					end
+				end
+				
+				return listeners
+			rescue Errno::ENOENT, Errno::EACCES
+				return {}
+			end
+			
+			# Parse /proc/net/unix and extract listener statistics for Unix domain sockets.
+			# @parameter paths [Array(String) | Nil] Optional filter for specific socket paths.
+			# @parameter file [String] Optional path to Unix socket file (defaults to "/proc/net/unix").
+			# @returns [Hash(String, Listener)] Hash mapping socket path to Listener.
+			def self.capture_unix(paths = nil, file: "/proc/net/unix")
+				listeners = {}
+				path_filter = paths ? paths.to_set : nil
+				
+				File.foreach(file) do |line|
+					line = line.strip
+					next if line.start_with?("Num")
+					
+					# Format: Num RefCount Protocol Flags Type St Inode Path
+					# Example (stripped): "00000000cf265b54: 00000003 00000000 00000000 0001 03 18324 /run/user/1000/wayland-0"
+					# After splitting by whitespace:
+					# [0] = "00000000cf265b54:", [1] = RefCount, [2] = Protocol, [3] = Flags, [4] = Type, [5] = St, [6] = Inode, [7+] = Path
+					fields = line.split(/\s+/)
+					next if fields.size < 7
+					
+					# State field is at index 5 (St)
+					# 01 = SS_UNCONNECTED (listening), 02 = SS_CONNECTING (queued), 03 = SS_CONNECTED (active)
+					state_hex = fields[5]
+					# Path starts at index 7
+					path = fields[7..-1]&.join(" ") || ""
+					
+					# Apply filter if specified
+					next if path_filter && !path_filter.include?(path)
+					next if path.empty?
+					
+					state = state_hex.to_i(16)
+					
+					listeners[path] ||= Listener.zero
+					
+					case state
+					when SS_CONNECTING # Queued connections
+						listeners[path].queue_size += 1
+					when SS_CONNECTED # Active connections
+						listeners[path].active_connections += 1
+					end
+				end
+				
+				return listeners
+			rescue Errno::ENOENT, Errno::EACCES
+				return {}
+			end
+			
+			# Parse /proc/net/tcp and /proc/net/tcp6 and extract listener statistics.
+			# @parameter addresses [Array(String) | Nil] Optional filter for specific addresses.
+			# @returns [Hash(String, Listener)] Hash mapping "ip:port" or "[ipv6]:port" to Listener.
+			def self.capture_tcp(addresses = nil)
+				listeners = {}
+				
+				# Capture IPv4 listeners and connections
+				if File.readable?("/proc/net/tcp")
+					listeners.merge!(capture_tcp_file("/proc/net/tcp", addresses, ipv6: false))
+				end
+				
+				# Capture IPv6 listeners and connections
+				if File.readable?("/proc/net/tcp6")
+					listeners.merge!(capture_tcp_file("/proc/net/tcp6", addresses, ipv6: true))
+				end
+				
+				return listeners
+			end
+			
+			# Capture listener listeners for TCP and/or Unix domain sockets.
+			# @parameter addresses [Array(String) | Nil] TCP address(es) to capture, e.g. ["0.0.0.0:80"]. If nil and paths is nil, captures all. If nil but paths specified, captures none.
+			# @parameter paths [Array(String) | Nil] Unix socket path(s) to capture. If nil and addresses is nil, captures all. If nil but addresses specified, captures none.
+			# @parameter unix_file [String] Optional path to Unix socket file (defaults to "/proc/net/unix").
+			# @returns [Hash(String, Listener)] Hash mapping addresses/paths to Listener.
+			def self.capture(addresses: nil, paths: nil, unix_file: "/proc/net/unix")
+				listeners = {}
+				
+				# If addresses are specified but paths is nil, don't capture Unix sockets
+				# Only capture Unix sockets if paths is explicitly provided or addresses is nil
+				tcp_addresses = addresses.nil? && !paths.nil? ? :skip : addresses
+				unix_paths = paths.nil? && !addresses.nil? ? :skip : paths
+				
+				# Capture TCP listeners (only if not skipped)
+				listeners.merge!(capture_tcp(tcp_addresses)) unless tcp_addresses == :skip
+				
+				# Capture Unix domain socket listeners (only if not skipped)
+				listeners.merge!(capture_unix(unix_paths, file: unix_file)) unless unix_paths == :skip
+				
+				return listeners
+			end
+		end
+	end
+end
+
+# Wire Listener.capture and Listener.supported? to this implementation on Linux.
+if IO::Metrics::Listener::Linux.supported?
+	class << IO::Metrics::Listener
+		# Whether listener capture is supported on this platform.
+		# @returns [Boolean] True if /proc/net/tcp is readable.
+		def supported?
+			true
+		end
+		
+		# Capture listener listeners for the given address(es).
+		# @parameter addresses [Array(String) | Nil] TCP address(es) to capture, e.g. ["0.0.0.0:80"]. If nil, captures all listening TCP sockets.
+		# @parameter paths [Array(String) | Nil] Unix socket path(s) to capture. If nil and addresses is nil, captures all. If nil but addresses specified, captures none.
+		# @returns [Hash(String, Listener) | Nil] A hash mapping addresses/paths to Listener, or nil if not supported.
+		def capture(**options)
+			IO::Metrics::Listener::Linux.capture(**options)
+		end
+	end
+end

data/lib/io/metrics/listener.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require "json"
+
+class IO
+	module Metrics
+		# Represents a network listener socket with its queue statistics.
+		# @attribute queue_size [Integer] Number of connections waiting to be accepted (queued).
+		# @attribute active_connections [Integer] Number of active connections (already accepted).
+		class Listener < Struct.new(:queue_size, :active_connections)
+			alias as_json to_h
+			
+			# Convert the object to a JSON string.
+			def to_json(*arguments)
+				as_json.to_json(*arguments)
+			end
+			
+			# Create a zero-initialized Listener instance.
+			# @returns [Listener] A new Listener object with all fields set to zero.
+			def self.zero
+				self.new(0, 0)
+			end
+			
+			# Whether listener stats can be captured on this system.
+			def self.supported?
+				false
+			end
+			
+			# Capture listener stats for the given address(es).
+			# @parameter addresses [Array(String) | Nil] TCP address(es) to capture, e.g. ["0.0.0.0:80"]. If nil, captures all listening TCP sockets.
+			# @parameter paths [Array(String) | Nil] Unix socket path(s) to capture. If nil and addresses is nil, captures all. If nil but addresses specified, captures none.
+			# @returns [Hash(String, Listener) | Nil] A hash mapping addresses/paths to Listener, or nil if not supported.
+			def self.capture(**options)
+				return nil
+			end
+		end
+	end
+end
+
+if RUBY_PLATFORM.include?("linux")
+	require_relative "listener/linux"
+elsif RUBY_PLATFORM.include?("darwin")
+	require_relative "listener/darwin"
+end

data/lib/io/metrics/version.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+# @namespace
+class IO
+	# @namespace
+	module Metrics
+		VERSION = "0.1.0"
+	end
+end

data/lib/io/metrics.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Samuel Williams.
+
+require_relative "metrics/version"
+require_relative "metrics/listener"

data/license.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright, 2026, by Samuel Williams.  
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/readme.md

@@ -0,0 +1,29 @@
+# IO::Metrics
+
+Extract I/O metrics from the host system, specifically listen queue statistics.
+
+[![Development Status](https://github.com/socketry/io-metrics/workflows/Test/badge.svg)](https://github.com/socketry/io-metrics/actions?workflow=Test)
+
+## Usage
+
+Please see the [project documentation](https://socketry.github.io/io-metrics/) for more details.
+
+  - [Getting Started](https://socketry.github.io/io-metrics/guides/getting-started/index) - This guide explains how to use `io-metrics` to capture listener queue statistics from the host operating system.
+
+## Contributing
+
+We welcome contributions to this project.
+
+1.  Fork it.
+2.  Create your feature branch (`git checkout -b my-new-feature`).
+3.  Commit your changes (`git commit -am 'Add some feature'`).
+4.  Push to the branch (`git push origin my-new-feature`).
+5.  Create new Pull Request.
+
+### Developer Certificate of Origin
+
+In order to protect users of this project, we require all contributors to comply with the [Developer Certificate of Origin](https://developercertificate.org/). This ensures that all contributions are properly licensed and attributed.
+
+### Community Guidelines
+
+This project is best served by a collaborative and respectful environment. Treat each other professionally, respect differing viewpoints, and engage constructively. Harassment, discrimination, or harmful behavior is not tolerated. Communicate clearly, listen actively, and support one another. If any issues arise, please inform the project maintainers.

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: io-metrics
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Samuel Williams
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIE2DCCA0CgAwIBAgIBATANBgkqhkiG9w0BAQsFADBhMRgwFgYDVQQDDA9zYW11
+  ZWwud2lsbGlhbXMxHTAbBgoJkiaJk/IsZAEZFg1vcmlvbnRyYW5zZmVyMRIwEAYK
+  CZImiZPyLGQBGRYCY28xEjAQBgoJkiaJk/IsZAEZFgJuejAeFw0yMjA4MDYwNDUz
+  MjRaFw0zMjA4MDMwNDUzMjRaMGExGDAWBgNVBAMMD3NhbXVlbC53aWxsaWFtczEd
+  MBsGCgmSJomT8ixkARkWDW9yaW9udHJhbnNmZXIxEjAQBgoJkiaJk/IsZAEZFgJj
+  bzESMBAGCgmSJomT8ixkARkWAm56MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIB
+  igKCAYEAomvSopQXQ24+9DBB6I6jxRI2auu3VVb4nOjmmHq7XWM4u3HL+pni63X2
+  9qZdoq9xt7H+RPbwL28LDpDNflYQXoOhoVhQ37Pjn9YDjl8/4/9xa9+NUpl9XDIW
+  sGkaOY0eqsQm1pEWkHJr3zn/fxoKPZPfaJOglovdxf7dgsHz67Xgd/ka+Wo1YqoE
+  e5AUKRwUuvaUaumAKgPH+4E4oiLXI4T1Ff5Q7xxv6yXvHuYtlMHhYfgNn8iiW8WN
+  XibYXPNP7NtieSQqwR/xM6IRSoyXKuS+ZNGDPUUGk8RoiV/xvVN4LrVm9upSc0ss
+  RZ6qwOQmXCo/lLcDUxJAgG95cPw//sI00tZan75VgsGzSWAOdjQpFM0l4dxvKwHn
+  tUeT3ZsAgt0JnGqNm2Bkz81kG4A2hSyFZTFA8vZGhp+hz+8Q573tAR89y9YJBdYM
+  zp0FM4zwMNEUwgfRzv1tEVVUEXmoFCyhzonUUw4nE4CFu/sE3ffhjKcXcY//qiSW
+  xm4erY3XAgMBAAGjgZowgZcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0O
+  BBYEFO9t7XWuFf2SKLmuijgqR4sGDlRsMC4GA1UdEQQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MC4GA1UdEgQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MA0GCSqGSIb3DQEBCwUAA4IBgQB5sxkE
+  cBsSYwK6fYpM+hA5B5yZY2+L0Z+27jF1pWGgbhPH8/FjjBLVn+VFok3CDpRqwXCl
+  xCO40JEkKdznNy2avOMra6PFiQyOE74kCtv7P+Fdc+FhgqI5lMon6tt9rNeXmnW/
+  c1NaMRdxy999hmRGzUSFjozcCwxpy/LwabxtdXwXgSay4mQ32EDjqR1TixS1+smp
+  8C/NCWgpIfzpHGJsjvmH2wAfKtTTqB9CVKLCWEnCHyCaRVuKkrKjqhYCdmMBqCws
+  JkxfQWC+jBVeG9ZtPhQgZpfhvh+6hMhraUYRQ6XGyvBqEUe+yo6DKIT3MtGE2+CP
+  eX9i9ZWBydWb8/rvmwmX2kkcBbX0hZS1rcR593hGc61JR6lvkGYQ2MYskBveyaxt
+  Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
+  voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
+  -----END CERTIFICATE-----
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: console
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/io/metrics.rb
+- lib/io/metrics/listener.rb
+- lib/io/metrics/listener/darwin.rb
+- lib/io/metrics/listener/linux.rb
+- lib/io/metrics/version.rb
+- license.md
+- readme.md
+homepage: https://github.com/socketry/io-metrics
+licenses:
+- MIT
+metadata:
+  documentation_uri: https://socketry.github.io/io-metrics/
+  funding_uri: https://github.com/sponsors/ioquatix
+  source_code_uri: https://github.com/socketry/io-metrics.git
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Extract I/O metrics from the host system.
+test_files: []