snowflaked 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b821e9cbccec942c789a9d8b0afb547c1cba389283f46169623c4f185753bbd
-  data.tar.gz: 763c5b9c22393698b115742b50f51fbbbc122810e8c6a2942ee14032171ecb5b
+  metadata.gz: 2d0d8f2af68a50e38cc1aa32c1adc0641fbcdb2d0f01d0bc6e942520da33089f
+  data.tar.gz: 47f1b23d9a38e2f60ab43f7059c8efd27b783012fbdc8f510ed220b221e3200d
 SHA512:
-  metadata.gz: dc619f463e94136072da4ecc99532e33a21616b86bf32828fbe91ee24206e9bdcb64b384b425d631b6c386317d48f8edb490ca7a5c21de8cdd55fa65586ae486
-  data.tar.gz: 932623948b2a6cffa8cced8864e4fdd7efc837fb3f1f06051e4634ccad74840cfc49720377cf4ac20cf6dce19fd1c83895138d57d8af28a5ecf5eabb40b8886c
+  metadata.gz: '0278267978cd6a55be0f569659f36ff841c874cbeb2e813cc7f88c1789cf6d8b7ef21886d0bffe1f3268b9c34e1dede2b2eea75ba77468760acbf956d069d57f'
+  data.tar.gz: 8f2dc54ef2896404ee4698644844ca2611ccb7b6339735ffeb0a7e2dc38854b1df73035c9e7f66a92202c6b5001760b814907303007db2c327dd32195b1d917f

data/README.md

@@ -1,5 +1,10 @@
 # Snowflaked
 
+[![CI](https://github.com/luizkowalski/snowflaked/actions/workflows/ci.yml/badge.svg)](https://github.com/luizkowalski/snowflaked/actions/workflows/ci.yml)
+[![Gem Version](https://badge.fury.io/rb/snowflaked.svg)](https://badge.fury.io/rb/snowflaked)
+[![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.
 
 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.
@@ -38,16 +43,22 @@ class CreateUsers < ActiveRecord::Migration[8.1]
   def change
     create_table :users do |t|
       t.snowflake :external_id
+      t.bigint    :uid
     end
   end
 end
 ```
 
+Columns created with `t.snowflake` are automatically detected and will have Snowflake IDs generated for them.
+
+> [!WARNING]
+> SQLite does not support column comments, which Snowflaked uses to auto-detect snowflake columns other than `:id`. When using SQLite, you must explicitly declare snowflake columns using the `snowflake_id` helper in your model.
+
 If you want to generate Snowflake IDs for additional columns, you can do so by using the `snowflake_id` method, without having to migrate the table:
 
 ```ruby
 class User < ApplicationRecord
-  snowflake_id :external_id
+  snowflake_id :uid
 end
 ```
 
@@ -72,10 +83,17 @@ end
 ```ruby
 Snowflaked.configure do |config|
   config.machine_id = 42
-  config.epoch = Time.utc(2020, 1, 1)
+  config.epoch = Time.utc(1989, 1, 3) # When not configured, the epoch is set to the Unix epoch (January 1, 1970)
 end
 ```
 
+### Machine ID
+
+> [!TIP]
+> For multi-process servers like Puma, it is recommended to **not** configure `machine_id` explicitly. The gem automatically calculates a unique machine ID using `(hostname.hash ^ pid) % 1024`, which ensures each forked worker process gets a different ID and avoids duplicate Snowflake IDs.
+
+If you must set `machine_id` explicitly, use environment variables that differ per worker process.
+
 ### Machine ID Resolution
 
 If `machine_id` is not explicitly configured, it resolves in this order:
@@ -140,6 +158,10 @@ bundle install
 bundle exec rake
 ```
 
+## Acknowledgments
+
+- [snowflaked-rs](https://github.com/MrGunflame/snowflaked-rs) - the Rust implementation of Snowflake IDs
+
 ## License
 
 MIT

data/ext/snowflaked/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "snowflaked"
-version = "0.1.0"
+version = "0.1.3"
 edition = "2021"
 publish = false
 

data/ext/snowflaked/src/lib.rs

@@ -1,42 +1,65 @@
 use magnus::{function, prelude::*, Error, RHash, Ruby};
 use snowflaked::sync::Generator;
-use snowflaked::Snowflake;
-use std::sync::OnceLock;
+use snowflaked::{Builder, Snowflake};
+use std::sync::RwLock;
+use std::time::UNIX_EPOCH;
 
 struct GeneratorState {
     generator: Generator,
     epoch_offset: u64,
     machine_id: u16,
+    init_pid: u32,
 }
 
-static STATE: OnceLock<GeneratorState> = OnceLock::new();
+static STATE: RwLock<Option<GeneratorState>> = RwLock::new(None);
 
 fn init_generator(machine_id: u16, epoch_ms: Option<u64>) -> bool {
-    let was_empty = STATE.get().is_none();
+    let current_pid = std::process::id();
+    let epoch_offset = epoch_ms.unwrap_or(0);
 
-    STATE.get_or_init(|| GeneratorState {
-        generator: Generator::new(machine_id),
-        epoch_offset: epoch_ms.unwrap_or(0),
+    let mut state = STATE.write().unwrap();
+
+    if state.as_ref().is_some_and(|s| s.init_pid == current_pid) {
+        return 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,
+        epoch_offset,
         machine_id,
+        init_pid: current_pid,
     });
 
-    was_empty
+    true
 }
 
 fn generate(ruby: &Ruby) -> Result<u64, Error> {
-    let state = STATE.get().ok_or_else(|| {
+    let state = STATE.read().unwrap();
+
+    let s = state.as_ref().ok_or_else(|| {
         Error::new(
             ruby.exception_runtime_error(),
             "Generator not initialized. Call Snowflaked.configure or Snowflaked.id first.",
         )
     })?;
 
-    Ok(state.generator.generate())
+    if s.init_pid != std::process::id() {
+        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.",
+        ));
+    }
+
+    Ok(s.generator.generate())
 }
 
 fn timestamp_ms(id: u64) -> u64 {
     let timestamp_raw = id.timestamp();
-    let epoch_offset = STATE.get().map(|s| s.epoch_offset).unwrap_or(0);
+    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)
 }
 
@@ -59,11 +82,13 @@ fn sequence(id: u64) -> u64 {
 }
 
 fn is_initialized() -> bool {
-    STATE.get().is_some()
+    let state = STATE.read().unwrap();
+    state.as_ref().is_some_and(|s| s.init_pid == std::process::id())
 }
 
 fn configured_machine_id() -> Option<u16> {
-    STATE.get().map(|s| s.machine_id)
+    let state = STATE.read().unwrap();
+    state.as_ref().and_then(|s| if s.init_pid == std::process::id() { Some(s.machine_id) } else { None })
 }
 
 #[magnus::init]

data/lib/snowflaked/model_extensions.rb

@@ -5,7 +5,7 @@ module Snowflaked
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :_snowflake_attributes, instance_writer: false, default: [:id] # rubocop:disable ThreadSafety/ClassAndModuleAttributes -- false positive
+      class_attribute :_snowflake_attributes, instance_writer: false, default: [:id]
       before_validation :_generate_snowflake_ids, on: :create
     end
 
@@ -17,9 +17,13 @@ module Snowflaked
       end
 
       def _snowflake_columns_from_comments
-        return [] unless table_exists?
+        return @_snowflake_columns_from_comments if defined?(@_snowflake_columns_from_comments)
 
-        columns.select { |c| c.comment == Snowflaked::SchemaDefinitions::COMMENT }.map { |c| c.name.to_sym }
+        @_snowflake_columns_from_comments = if table_exists?
+          columns.filter_map { |col| col.name.to_sym if col.comment == Snowflaked::SchemaDefinitions::COMMENT }
+        else
+          []
+        end
       end
     end
 

data/lib/snowflaked/schema_definitions.rb

@@ -4,18 +4,13 @@ module Snowflaked
   module SchemaDefinitions
     COMMENT = "snowflaked"
 
-    module TableDefinition
-      def snowflake(name, **options)
-        options[:comment] = Snowflaked::SchemaDefinitions::COMMENT
-        column(name, :snowflake, **options)
+    module SnowflakeColumn
+      def snowflake(name, **)
+        column(name, :snowflake, comment: COMMENT, **)
       end
     end
 
-    module Table
-      def snowflake(name, **options)
-        options[:comment] = Snowflaked::SchemaDefinitions::COMMENT
-        column(name, :snowflake, **options)
-      end
-    end
+    TableDefinition = SnowflakeColumn
+    Table           = SnowflakeColumn
   end
 end

data/lib/snowflaked/version.rb

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

data/lib/snowflaked.rb

@@ -57,7 +57,7 @@ module Snowflaked
 
   class << self
     def configuration
-      @configuration ||= Configuration.new # rubocop:disable ThreadSafety/ClassInstanceVariable -- not changed after initialization
+      @configuration ||= Configuration.new
     end
 
     def configure

metadata

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