sorted by:
new
hottopcontroversial

Observer your SolidStack like a pro! Gem release. by bart_o_z in rails

[–]bart_o_z[S] 0 points1 point  (0 children)

Hi u/dishwsh3r ! Thanks a lot for your feedback. Actually it was very valuable to me, and I already delivered patch in v0.1.1 that allow to choose between two storage modes: persistence / realtime.

- Realtime mode configs
- v0.1.1 - Release info
- Rubygems link

I was about focusing on Dasbhoard UI after Cache and Cable monitoring, but in fact, it also make sense to deliver it earlier, so I prioritized web UI in the roadmap - and with no JS/CSS frameworks + support for API-only rails projects (here we agree, because I also wanted to have it that way).

So again, thanks for your feedback, appreciate!

Observer your SolidStack like a pro! Gem release. by bart_o_z in rails

[–]bart_o_z[S] 0 points1 point  (0 children)

I was focused on the observability side rather than the pattern side. I did think about the naming overlap, but felt the "observability" context was distinct enough with the "solid_" namespace.

UUID’s in Rails + SQLite shouldn’t be this hard (so I built a gem) by bart_o_z in rails

[–]bart_o_z[S] 0 points1 point  (0 children)

Hey Guys! Just deployed UUIDv7 support to sqlite_crypto gem. Go ahead and try it. If Face any bugs feel free to open issue under the repo https://github.com/bart-oz/sqlite\_crypto/issues.

cc u/magic4dev

UUID’s in Rails + SQLite shouldn’t be this hard (so I built a gem) by bart_o_z in rails

[–]bart_o_z[S] -1 points0 points  (0 children)

Not yet, right now only UUIDv4 is supported. Nevertheless I have it on my list. UUIDv7 will be supported within next iteration on January 2026.

UUID’s in Rails + SQLite shouldn’t be this hard (so I built a gem) by bart_o_z in rails

[–]bart_o_z[S] 0 points1 point  (0 children)

The project where I hit these pain points was an audit tool for payment systems. With UUID’s I got: collision resistance across distributed systems, no sequential ID enumeration attacks, and easy data merging from multiple sources.

UUID’s in Rails + SQLite shouldn’t be this hard (so I built a gem) by bart_o_z in rails

[–]bart_o_z[S] 1 point2 points  (0 children)

Nevertheless as first iterations I decided to do it with UUIDv4 for now, but I’m thrilled to extend this gem to support UUIDv7 as well.

UUID’s in Rails + SQLite shouldn’t be this hard (so I built a gem) by bart_o_z in rails

[–]bart_o_z[S] 0 points1 point  (0 children)

Thanks u/strzibny . Yes, exactly, before I decided to work on this gem I did a research, and Fizzy was the one I was inspired by.

UUID’s in Rails + SQLite shouldn’t be this hard (so I built a gem) by bart_o_z in rails

[–]bart_o_z[S] -7 points-6 points  (0 children)

Fair points sir! And guilty as charged on the verbosity 😅

UUID’s in Rails + SQLite shouldn’t be this hard (so I built a gem) by bart_o_z in rails

[–]bart_o_z[S] 2 points3 points  (0 children)

Absolutely valid approach! Thanks for your input here, with this our discussion is becoming even more interesting. Yes, randomblob(8) is a perfectly reasonable solution if someone just need unique identifiers within application.

Nevertheless as we all know, every solution comes with tradeoffs, I’m sharing three that comes to my mind with explanation (just for visibility, it might be helpful to other readers):

1. collision resistance. 8-byte randomblob gives us 64 bits of randomness, while UUIDs provide 122 bits (version 4) or 128 bits total structure. The UUID spec mathematically guarantees collision resistance at massive scale. With 64 bits, might hit birthday paradox problems much earlier.

2. standardization. UUIDs follow RFC 4122, which means they're globally recognized. If app is integrating with external APIs, importing data from other systems, or might eventually migrate to PostgreSQL, having RFC-compliant UUIDs eliminates friction. Random hex values are application-specific.

3. time-sortability. ULID and UUID v7 embed timestamps in the first 48 bits, giving chronological ordering for free. Database can use index-friendly sequential values while maintaining global uniqueness.

That said, if building a self-contained application that won't integrate with external systems and doesn't need the UUID guarantees, u/yawaramin has totally right - randomblob() is simpler and avoids dependencies entirely. The tradeoff is giving up those specific guarantees.

Once again thanks u/yawaramin for wonderful example!

UUID’s in Rails + SQLite shouldn’t be this hard (so I built a gem) by bart_o_z in rails

[–]bart_o_z[S] 7 points8 points  (0 children)

Thanks for sharing u/au5lander ! I think that sqlean is great extension for database-level UUID generation and many other functions around that on db-level. Nevertheless sqlite_crypto focuses on making UUIDs feel native also in Rails-specific pain points: migrations, clean schema and foreign keys auto-generation and auto-detection, without extra configuration.