snowflaked 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d0d8f2af68a50e38cc1aa32c1adc0641fbcdb2d0f01d0bc6e942520da33089f
-  data.tar.gz: 47f1b23d9a38e2f60ab43f7059c8efd27b783012fbdc8f510ed220b221e3200d
+  metadata.gz: 8614c6c1857513375925fcc710cae86379a5f3937e1128a76e7c0c9316e717d7
+  data.tar.gz: 2a229cc5321964620d03261fcaa7b757e2a46ae31519ba9d03a0bb18a4b37f90
 SHA512:
-  metadata.gz: '0278267978cd6a55be0f569659f36ff841c874cbeb2e813cc7f88c1789cf6d8b7ef21886d0bffe1f3268b9c34e1dede2b2eea75ba77468760acbf956d069d57f'
-  data.tar.gz: 8f2dc54ef2896404ee4698644844ca2611ccb7b6339735ffeb0a7e2dc38854b1df73035c9e7f66a92202c6b5001760b814907303007db2c327dd32195b1d917f
+  metadata.gz: d54e7b37a266cfa15f98d07e9723db9d218aff9301b7c1c0939d82f750ea91cbbfde65a7470b2b29a34d08b23b8a8a969e88e07af13b7f1af16f6eb6322b5648
+  data.tar.gz: a032245eec1c604d91bd3c51fefb3d5345cf693e8ff50c34dab29bd022d5c2c7fc77cabe32084e7a5955c25caaa7ffb903abc90d1d7d61b233fd6b0040f90a65

data/README.md

@@ -5,7 +5,7 @@
 [![Downloads](https://img.shields.io/gem/dt/snowflaked.svg)](https://rubygems.org/gems/snowflaked)
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE.txt)
 
-A high-performance, thread-safe Snowflake ID generator for Ruby, powered by Rust.
+A database-agnostic, high-performance, thread-safe Snowflake ID generator for Ruby, powered by Rust.
 
 Snowflake IDs are 64-bit unique identifiers that encode a timestamp, machine ID, and sequence number. They're time-sortable (IDs created later are always larger), making them ideal for distributed systems where you need unique IDs without coordination between machines. Unlike UUIDs, Snowflake IDs are smaller, sortable, and index-friendly for databases.
 
@@ -143,6 +143,12 @@ Snowflaked.machine_id(id)
 # => 42
 ```
 
+## Benchmarks
+
+See [BENCHMARKS.md](benchmarks/README.md) for more details.
+
+tl;dr: Snowflake IDs have a negligible performance impact compared to database-backed IDs.
+
 ## Requirements
 
 - Ruby >= 3.2

data/ext/snowflaked/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snowflaked"
-version = "0.1.3"
+version = "0.2.0"
 edition = "2021"
 publish = false
 
@@ -10,3 +10,4 @@ crate-type = ["cdylib"]
 [dependencies]
 magnus = { version = "0.8" }
 snowflaked = { version = "1.0.3", features = ["sync"] }
+arc-swap = "1.8.2"

data/ext/snowflaked/src/lib.rs

@@ -1,7 +1,8 @@
+use arc_swap::ArcSwapOption;
 use magnus::{function, prelude::*, Error, RHash, Ruby};
 use snowflaked::sync::Generator;
 use snowflaked::{Builder, Snowflake};
-use std::sync::RwLock;
+use std::sync::Arc;
 use std::time::UNIX_EPOCH;
 
 struct GeneratorState {
@@ -11,68 +12,88 @@ struct GeneratorState {
     init_pid: u32,
 }
 
-static STATE: RwLock<Option<GeneratorState>> = RwLock::new(None);
+static STATE: ArcSwapOption<GeneratorState> = ArcSwapOption::const_empty();
 
-fn init_generator(machine_id: u16, epoch_ms: Option<u64>) -> bool {
-    let current_pid = std::process::id();
-    let epoch_offset = epoch_ms.unwrap_or(0);
-
-    let mut state = STATE.write().unwrap();
+fn build_generator(machine_id: u16, epoch_offset: u64) -> Generator {
+    let epoch = UNIX_EPOCH + std::time::Duration::from_millis(epoch_offset);
+    Builder::new().instance(machine_id).epoch(epoch).build()
+}
 
-    if state.as_ref().is_some_and(|s| s.init_pid == current_pid) {
-        return false;
+fn ensure_state(machine_id: u16, epoch_offset: u64, current_pid: u32) -> (Arc<GeneratorState>, bool) {
+    if let Some(s) = &*STATE.load() {
+        if s.init_pid == current_pid {
+            return (Arc::clone(s), false);
+        }
     }
 
-    let epoch = UNIX_EPOCH + std::time::Duration::from_millis(epoch_offset);
-    let generator = Builder::new().instance(machine_id).epoch(epoch).build();
-
-    *state = Some(GeneratorState {
-        generator,
+    let new_state = Arc::new(GeneratorState {
+        generator: build_generator(machine_id, epoch_offset),
         epoch_offset,
         machine_id,
         init_pid: current_pid,
     });
 
-    true
-}
+    let prev_state = STATE.rcu(|current| {
+        if let Some(c) = current {
+            if c.init_pid == current_pid {
+                return Arc::clone(c);
+            }
+        }
+        Arc::clone(&new_state)
+    });
 
-fn generate(ruby: &Ruby) -> Result<u64, Error> {
-    let state = STATE.read().unwrap();
+    match prev_state.as_ref() {
+        Some(s) if s.init_pid == current_pid => (Arc::clone(s), false),
+        _ => (new_state, true),
+    }
+}
 
-    let s = state.as_ref().ok_or_else(|| {
-        Error::new(
-            ruby.exception_runtime_error(),
-            "Generator not initialized. Call Snowflaked.configure or Snowflaked.id first.",
-        )
-    })?;
+fn init_generator(machine_id: u16, epoch_ms: Option<u64>) -> bool {
+    let (_, swapped) = ensure_state(machine_id, epoch_ms.unwrap_or(0), std::process::id());
+    swapped
+}
 
-    if s.init_pid != std::process::id() {
+fn validate_config(ruby: &Ruby, s: &GeneratorState, machine_id: u16, epoch_offset: u64) -> Result<(), Error> {
+    if s.machine_id != machine_id || s.epoch_offset != epoch_offset {
         return Err(Error::new(
             ruby.exception_runtime_error(),
-            "Fork detected: generator was initialized in a different process. This should not happen if using Snowflaked.id - please report this bug.",
+            "Generator already initialized with a different machine_id or epoch for this process",
         ));
     }
+    Ok(())
+}
+
+fn generate(ruby: &Ruby, machine_id: u16, epoch_ms: Option<u64>) -> Result<u64, Error> {
+    let epoch_offset = epoch_ms.unwrap_or(0);
+    let (state, _) = ensure_state(machine_id, epoch_offset, std::process::id());
 
-    Ok(s.generator.generate())
+    validate_config(ruby, &state, machine_id, epoch_offset)?;
+    Ok(state.generator.generate())
 }
 
-fn timestamp_ms(id: u64) -> u64 {
-    let timestamp_raw = id.timestamp();
-    let state = STATE.read().unwrap();
-    let epoch_offset = state.as_ref().map(|s| s.epoch_offset).unwrap_or(0);
-    timestamp_raw.saturating_add(epoch_offset)
+fn epoch_offset(ruby: &Ruby) -> Result<u64, Error> {
+    STATE
+        .load()
+        .as_ref()
+        .map(|s| s.epoch_offset)
+        .ok_or_else(|| Error::new(ruby.exception_runtime_error(), "Generator not initialized"))
 }
 
 fn parse(ruby: &Ruby, id: u64) -> Result<RHash, Error> {
+    let offset = epoch_offset(ruby)?;
     let hash = ruby.hash_new();
 
-    hash.aset(ruby.to_symbol("timestamp_ms"), timestamp_ms(id))?;
-    hash.aset(ruby.to_symbol("machine_id"), machine_id_from_id(id))?;
-    hash.aset(ruby.to_symbol("sequence"), sequence(id))?;
+    hash.aset(ruby.to_symbol("timestamp_ms"), id.timestamp().saturating_add(offset))?;
+    hash.aset(ruby.to_symbol("machine_id"), id.instance())?;
+    hash.aset(ruby.to_symbol("sequence"), id.sequence())?;
 
     Ok(hash)
 }
 
+fn timestamp_ms(ruby: &Ruby, id: u64) -> Result<u64, Error> {
+    epoch_offset(ruby).map(|offset| id.timestamp().saturating_add(offset))
+}
+
 fn machine_id_from_id(id: u64) -> u64 {
     id.instance()
 }
@@ -82,13 +103,11 @@ fn sequence(id: u64) -> u64 {
 }
 
 fn is_initialized() -> bool {
-    let state = STATE.read().unwrap();
-    state.as_ref().is_some_and(|s| s.init_pid == std::process::id())
+    STATE.load().as_ref().is_some_and(|s| s.init_pid == std::process::id())
 }
 
 fn configured_machine_id() -> Option<u16> {
-    let state = STATE.read().unwrap();
-    state.as_ref().and_then(|s| if s.init_pid == std::process::id() { Some(s.machine_id) } else { None })
+    STATE.load().as_ref().filter(|s| s.init_pid == std::process::id()).map(|s| s.machine_id)
 }
 
 #[magnus::init]
@@ -97,7 +116,7 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     let internal = module.define_module("Native")?;
 
     internal.define_singleton_method("init_generator", function!(init_generator, 2))?;
-    internal.define_singleton_method("generate", function!(generate, 0))?;
+    internal.define_singleton_method("generate", function!(generate, 2))?;
     internal.define_singleton_method("parse", function!(parse, 1))?;
     internal.define_singleton_method("timestamp_ms", function!(timestamp_ms, 1))?;
     internal.define_singleton_method("machine_id", function!(machine_id_from_id, 1))?;

data/lib/snowflaked/model_extensions.rb

@@ -14,25 +14,27 @@ module Snowflaked
         attrs = attributes.map(&:to_sym)
         attrs |= [:id] if id
         self._snowflake_attributes = attrs
+        @_snowflake_attributes_with_columns = nil
       end
 
       def _snowflake_columns_from_comments
         return @_snowflake_columns_from_comments if defined?(@_snowflake_columns_from_comments)
 
-        @_snowflake_columns_from_comments = if table_exists?
-          columns.filter_map { |col| col.name.to_sym if col.comment == Snowflaked::SchemaDefinitions::COMMENT }
-        else
-          []
-        end
+        @_snowflake_columns_from_comments = table_exists? ? columns.filter_map { |col| col.name.to_sym if col.comment == Snowflaked::SchemaDefinitions::COMMENT } : []
+      end
+
+      def _snowflake_attributes_with_columns
+        @_snowflake_attributes_with_columns ||= (_snowflake_attributes | _snowflake_columns_from_comments)
       end
     end
 
     private
 
     def _generate_snowflake_ids
-      attributes_to_generate = self.class._snowflake_attributes | self.class._snowflake_columns_from_comments
+      attributes = self.class._snowflake_attributes_with_columns
+      return if attributes.empty?
 
-      attributes_to_generate.each do |attribute|
+      attributes.each do |attribute|
         next if self[attribute].present?
 
         self[attribute] = Snowflaked.id

data/lib/snowflaked/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Snowflaked
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

data/lib/snowflaked.rb

@@ -29,8 +29,7 @@ module Snowflaked
     end
 
     def machine_id_value
-      id = @machine_id || default_machine_id
-      id % (MAX_MACHINE_ID + 1)
+      (@machine_id || default_machine_id) % (MAX_MACHINE_ID + 1)
     end
 
     def epoch_ms
@@ -46,8 +45,7 @@ module Snowflaked
     end
 
     def env_machine_id
-      id = ENV["SNOWFLAKED_MACHINE_ID"] || ENV.fetch("MACHINE_ID", nil)
-      id&.to_i
+      (ENV["SNOWFLAKED_MACHINE_ID"] || ENV.fetch("MACHINE_ID", nil))&.to_i
     end
 
     def hostname_pid_hash
@@ -68,8 +66,8 @@ module Snowflaked
     end
 
     def id
-      ensure_initialized!
-      Native.generate
+      config = configuration
+      Native.generate(config.machine_id_value, config.epoch_ms)
     end
 
     def parse(id)
@@ -78,16 +76,17 @@ module Snowflaked
     end
 
     def timestamp(id)
-      time_ms = Native.timestamp_ms(id)
-      Time.at(time_ms / 1000, (time_ms % 1000) * 1000, :usec)
+      ensure_initialized!
+      seconds, milliseconds = Native.timestamp_ms(id).divmod(1000)
+      Time.at(seconds, milliseconds * 1000, :usec)
     end
 
     def machine_id(id)
-      ensure_initialized!
       Native.machine_id(id)
     end
 
     def timestamp_ms(id)
+      ensure_initialized!
       Native.timestamp_ms(id)
     end
 
@@ -100,8 +99,7 @@ module Snowflaked
     def ensure_initialized!
       return if Native.initialized?
 
-      config = configuration
-      Native.init_generator(config.machine_id_value, config.epoch_ms)
+      Native.init_generator(configuration.machine_id_value, configuration.epoch_ms)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: snowflaked
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Luiz Eduardo Kowalski