snowflaked 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a6f86e1432fc8b11f282674da8568ffecb835bb5aba3d5c52c124acb4a55ace
-  data.tar.gz: 2d13a338cceed05710c0afa3e56896d8199d90b1934ac259e256bed49ba8c3cf
+  metadata.gz: 8614c6c1857513375925fcc710cae86379a5f3937e1128a76e7c0c9316e717d7
+  data.tar.gz: 2a229cc5321964620d03261fcaa7b757e2a46ae31519ba9d03a0bb18a4b37f90
 SHA512:
-  metadata.gz: 54d45cfb0b0f503e8cc839ac7530439582e08ee11a98e3ec8a79bd9cc3bb0539cd8a0096e2d6618a9015c712bc02e8423ee18dc3d325eb695bdb4e413ad998dd
-  data.tar.gz: 4f291445d0e558e1e856f146d5972d52ac068ee907cb20aa4a2ea8d9eb0be818c3d4b53738e0b3ade960662aa8a5f05e6e616f210e0c7a3de7c37d089cbe9454
+  metadata.gz: d54e7b37a266cfa15f98d07e9723db9d218aff9301b7c1c0939d82f750ea91cbbfde65a7470b2b29a34d08b23b8a8a969e88e07af13b7f1af16f6eb6322b5648
+  data.tar.gz: a032245eec1c604d91bd3c51fefb3d5345cf693e8ff50c34dab29bd022d5c2c7fc77cabe32084e7a5955c25caaa7ffb903abc90d1d7d61b233fd6b0040f90a65

data/README.md

@@ -145,7 +145,7 @@ Snowflaked.machine_id(id)
 
 ## Benchmarks
 
-See [BENCHMARKS.md](benchmarks/BENCHMARKS.md) for more details.
+See [BENCHMARKS.md](benchmarks/README.md) for more details.
 
 tl;dr: Snowflake IDs have a negligible performance impact compared to database-backed IDs.
 

data/ext/snowflaked/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snowflaked"
-version = "0.1.4"
+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

@@ -6,7 +6,7 @@ module Snowflaked
 
     included do
       class_attribute :_snowflake_attributes, instance_writer: false, default: [:id]
-      after_initialize :_generate_snowflake_ids, if: :new_record?
+      before_validation :_generate_snowflake_ids, on: :create
     end
 
     class_methods do
@@ -20,11 +20,7 @@ module Snowflaked
       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
@@ -35,10 +31,10 @@ module Snowflaked
     private
 
     def _generate_snowflake_ids
-      attributes_to_generate = self.class._snowflake_attributes_with_columns
-      return if attributes_to_generate.empty?
+      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.4"
+  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.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Luiz Eduardo Kowalski