Ruby on Rails

• What is going wrong with your DB that its built-in caching is insufficient?
• Load, there are millions of queries running a sec now, and the Active Model classes I want to update are read constantly but hardly ever written
• Have you exhausted your performance-tuning options in the DB layer?
• I'm not an expert on this, but I understand that yeah performance tuning only got that far
• Have you measured a significant performance problem in the first place?
• This investigation is looking at the future, I'll need to serve 20times more traffic
• Do you *really* need to serialize the entire record or could you cache just what you need?
• I'm actually writing services in another language, that could fetch this data from the same cache, reads are all concentrated in my Rails app
• So I'm actually looking forward to serialize a "row" to Thrift/Avro/Proto, save it somewhere, and then use it read it from there (redis/memcached) instead of issuing queries for data that doesn't change
• I'm after two goals
• Improve performance of my rails monolith
• Make this data available for other services 
• Have you considered the difficulty of keeping two data stores in sync?
• I've done this in the past, exact same idea but on a custom MVC without ORM and it worked perfectly, improved performance, actually the system later on, faced a point by which cache invalidations became problematic: the system couldn't operate any longer without it's cache warm enough
  

It might be *possible* but I would strongly suggest rethinking this.

What is going wrong with your DB that its built-in caching is insufficient?
Have you exhausted your performance-tuning options in the DB layer?
Have you measured a significant performance problem in the first place?
Do you *really* need to serialize the entire record or could you cache just what you need?

Have you considered the difficulty of keeping two data stores in sync?

If you can confidently answer all of those questions and you still want to pursue this design, then I would begin again with a data-mapper pattern instead.

On Tuesday, December 3, 2019 at 1:05:47 PM UTC-6, Daniel Baez wrote:

Hello,

Lets say that I have a model class like `Car < ActiveRecord::Base` and then, I want to extend it with an abstract class in between a sort of `Car < CacheableActiveRecord::Base < ActiveRecord::Base`

In `CacheableActiveRecord::Base` I'll overwrite methods like `find_by`, `find_by!` and `find` with the intention of checking out Redis/Memcached before calling super and letting Rails resolve this to the underlying db, I'm using Rails 4.2.7.1

By extending `Car` an `after_commit` hook will be created for each instance of the `Car` class, that hook will clear the cached key for this model upon commit, This is to get the effect, of releasing the cache on save.

This is an implementation for my `find` method in `CacheableActiveRecord::Base`

```

    def self.find(*ids)

      expects_array = ids.first.kind_of?(Array)

      return ids.first if expects_array && ids.first.empty?

      ids = ids.flatten.compact.uniq

      case ids.size

      when 0

        super # calling supper will generate an exception at this point

      when 1

        id = ids.first

        result = get_from_cache(id)

        unless result

          result = super # I expect this to get the data from db

          if result

            result = set_to_cache(id, result) 

          end

        end

        expects_array ? [ result ] : result

      else

        super # for now let's just skip on multiple ids

      end

    rescue RangeError

      raise RecordNotFound, "Couldn't find #{@klass.name} with an out of range ID"

    end

```

I have tests for this, and they even seem to work. for the implementation of `set_to_cache` and `get_from_cache` I have the following code

```

    def self.get_from_cache(entity_id)

      return nil unless entity_id

      cached = Rc.get!(get_cache_key(entity_id))

      if cached

        puts "cache hit"

      end

      return cached ? Marshal.load(cached) : nil

    end

    def self.set_to_cache(entity_id, entity)

      return nil unless entity && entity_id

      dump = Marshal.dump(entity) 

      Rc.set!(get_cache_key(entity_id), dump)

      return Marshal.load(dump) 

    end

```

My doubts here are:

• Is `Marshal` safe? can one do this? taking into account that this cache will be shared among instances of the same rails app, running in different servers.
• Is it better to serialize to json? is it possible to serialize to json and then rebuilt an object that will work as regular active record object? I mean one on which you can call `.where` queries on related objects and so on?

I'm a newbie to Rails and Ruby, started coding with both two weeks ago, my background is mostly java xD (finding Ruby great BY THE WAY hahaha)

Thank you

Daniel