litestack 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11ef03890b2883bd21fb443d959774f9932f56e927d2ee2a40a028713526ce9c
-  data.tar.gz: c531925eeffa84973475c14d4d230d8919d5e5ec095e5055f9bab6b0f94519e3
+  metadata.gz: 98a82dcbe7e4fe0b215e254fac5791127142fcbfd4a156b2509434f97b58aea9
+  data.tar.gz: a914b64d6e031559b1bdca83a8198426a49005f56ca1d0b4da2a7c6cb2384ab7
 SHA512:
-  metadata.gz: 82c0878fb57fa89290c6550ddbf5b393e436883252285dd78083ba7e96f78947aa3fdf3e92d96f3baec6b9b2b0d2edfdc470f4e1c544427f3da8db704179de27
-  data.tar.gz: 358bc249c3f1371714e12f4df0a0d82883e42eec14528f4faaef8a5e611e62af1039d8c00ebdc9d89be1a514a3bfd698ce3f988fa1b4f29eb1cf72fd1ca03b25
+  metadata.gz: 72935d15fcced99bcc0da9cfb6c1ffcd43478a5456c073a3d8ab468a3e49f7c681bbdec861cb7c1e2c16659e0d11429e16d855be38fd30735448078977205dc9
+  data.tar.gz: ac181213e66533926ce5d075e8256dcf2c5dfa727ff7becaa244bbf053f354c564f29a294f4b2b8c1436320d41e9dc4e4697ba9e3169324bc798c60d8bfc762a

data/.standard.yml

@@ -0,0 +1,3 @@
+ignore:
+  - 'test/**/*':
+    - Style/GlobalVars

data/BENCHMARKS.md

@@ -1,6 +1,6 @@
 # Litestack Benchmarks
 
-This is a set of initial (simple) benchmars, designed to understand the baseline performance for different litestack components against their counterparts. 
+This is a set of initial (simple) benchmarks, designed to understand the baseline performance for different litestack components against their counterparts. 
 These are not real life scenarios and I hope I will be able to produce some interesting ones soon.
 
 All these benchmarks were run on an 8 core, 16 thread, AMD 5700U based laptop, in a Virtual Box VM
@@ -18,7 +18,7 @@ This produces
 SELECT * FROM posts WHERE id = ?
 ```
 
-|Prcoesses|AR:PG|AR:litedb|Sequel:PG|Sequel:litedb|
+|Processes|AR:PG|AR:litedb|Sequel:PG|Sequel:litedb|
 |-:|-:|-:|-:|-:|
 |1|1.3K q/s|6.5K q/s|1.8K q/s|17.4K q/s|
 |2|2.6K q/s|13.9K q/s|3.5K q/s|33.2K q/s|
@@ -35,7 +35,7 @@ This produces
 SELECT * FROM posts WHERE user_id = ? LIMIT 5
 ```
 
-|Prcoesses|AR:PG|AR:litedb|Sequel:PG|Sequel:litedb|
+|Processes|AR:PG|AR:litedb|Sequel:PG|Sequel:litedb|
 |-:|-:|-:|-:|-:|
 |1|345 q/s|482 q/s|937 q/s|1.1K q/s|
 |2|751 q/s|848 q/s|1.3K q/s|2.3K q/s|
@@ -53,7 +53,7 @@ This produces
 Update posts SET updated_at = ? WHERE id = ?
 ```
 
-|Prcoesses|AR:PG|AR:litedb|Sequel:PG|Sequel:litedb|
+|Processes|AR:PG|AR:litedb|Sequel:PG|Sequel:litedb|
 |-:|-:|-:|-:|-:|
 |1|125 q/s|484 q/s|129 q/s|2.1K q/s|
 |2|265 q/s|576 q/s|333 q/s|2.5K q/s|
@@ -78,7 +78,7 @@ For testing the cache we attempted to try writing and reading different payload
 
 ### Read
 
-|Payload Size (bytes)|Redis|litecahce|
+|Payload Size (bytes)|Redis|litecache|
 |-:|-:|-:|
 |10|5.0K q/s|69.4K q/s|
 |100|5.0K q/s|90.7K q/s|
@@ -87,11 +87,11 @@ For testing the cache we attempted to try writing and reading different payload
 
 ### Increment an int value
 
-|Redis|litecahce|
+|Redis|litecache|
 |-:|-:|
 |5.1K q/s|16.9K q/s|
 
-It is not even a contest! litecache delivers way higher peroformance, specially in reading performance which is arguably the most important metric for a cache.
+It is not even a contest! litecache delivers way higher performance, specially in reading performance which is arguably the most important metric for a cache.
 
 > ![litejob](https://github.com/oldmoe/litestack/blob/master/assets/litejob_logo_teal.png?raw=true)
 
@@ -122,3 +122,19 @@ A client written using the Iodine web server was used to generate the WS load in
 |100,000|3403|5385|41|36|153|235
 
 On average, Litecable is quite faster than the Redis based version and offers better latenices for over 90% of the requests, though Redis usually delivers better p99 latencies, 
+
+> ![litesearch](https://github.com/oldmoe/litestack/blob/master/assets/litesearch_logo_teal.png?raw=true)
+
+Litesearch was benchmarked against Mielsearch, both using their respective ActiveRecord integrations. Mielsearch was running on the same machine as the benchmark script and was using the default configuration options. The dataset used for testing was the infamous Enron email corpus. Redisearch was not benchmarked due to the clients being not Rails 7.1 compatible (yet), will probably bench Redisearch when they are.
+
+### Building the index
+
+||MieliSearch|Litesearch|
+|-:|-:|-:|
+|Time to insert 10K docs|265.42 seconds|29.06 seconds|
+|Inserted docs/second|38|344|
+|Search latency (3 terms)|7.51 ms| 0.051ms|
+|Searches/second|133|19608|
+|Index rebuild|0.822|0.626|
+
+We only limited the test to 10K documents becuause MieliSearch was taking a long time to index, so we decided to stop at a reasonable sample size. The search numbers for litesearch were double checked, event against a 100K document set and they remained virtually the same. It is clear that litesearch is much faster than MieliSearch in both indexing and searching, this could be partially attributed to litesearch being a simpler text search engine, but still, the difference is huge! For rebuilding the index though, Litesearch is not that much faster than Mielisearch.

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
+## [0.4.2] - 2023-11-11
+
+- Add similarity search support for Litesearch (works best for non-trigram indexes)
+- Enable similarity search for ActiveRecord and Sequel models
+- Fix Litesearch tests
+- Suppress chatty Litejob exit detector when there are no jobs in flight
+- Tidy up the test folder
+- [#41](https://github.com/oldmoe/litestack/pull/41) - Fix bug in Litecable where the `connected` event was not getting propogated
+- Add Litemetric and Liteboard info to README.doc
+- Fix the testing rake task
+
 ## [0.4.1] - 2023-10-11
 
 - Add missing Litesearch::Model dependency

data/Gemfile

@@ -2,11 +2,5 @@
 
 source "https://rubygems.org"
 
-# Specify your gem's dependencies in ultralite.gemspec
+# Specify your gem's dependencies in litestack.gemspec
 gemspec
-
-
-
-gem "rack", "~> 3.0"
-
-gem "simplecov"

data/Gemfile.lock

@@ -0,0 +1,92 @@
+PATH
+  remote: .
+  specs:
+    litestack (0.4.1)
+      erubi
+      hanami-router
+      oj
+      rack
+      sqlite3
+      tilt
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    docile (1.4.0)
+    erubi (1.12.0)
+    hanami-router (0.6.2)
+      hanami-utils (~> 0.7)
+      http_router (~> 0.11)
+    hanami-utils (0.9.2)
+    http_router (0.11.2)
+      rack (>= 1.0.0)
+      url_mount (~> 0.2.1)
+    json (2.6.3)
+    language_server-protocol (3.17.0.3)
+    lint_roller (1.1.0)
+    minitest (5.19.0)
+    oj (3.15.1)
+    parallel (1.23.0)
+    parser (3.2.2.3)
+      ast (~> 2.4.1)
+      racc
+    racc (1.7.1)
+    rack (3.0.8)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.8.1)
+    rexml (3.2.6)
+    rubocop (1.52.1)
+      json (~> 2.3)
+      parallel (~> 1.10)
+      parser (>= 3.2.2.3)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.28.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.29.0)
+      parser (>= 3.2.1.0)
+    rubocop-performance (1.18.0)
+      rubocop (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    ruby-progressbar (1.13.0)
+    simplecov (0.22.0)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.12.3)
+    simplecov_json_formatter (0.1.4)
+    sqlite3 (1.6.3-arm64-darwin)
+    standard (1.30.1)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.52.0)
+      standard-custom (~> 1.0.0)
+      standard-performance (~> 1.1.0)
+    standard-custom (1.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.50)
+    standard-performance (1.1.2)
+      lint_roller (~> 1.1)
+      rubocop-performance (~> 1.18.0)
+    tilt (2.2.0)
+    unicode-display_width (2.4.2)
+    url_mount (0.2.1)
+      rack
+
+PLATFORMS
+  arm64-darwin-21
+
+DEPENDENCIES
+  litestack!
+  minitest (~> 5.0)
+  rack (~> 3.0)
+  rake (~> 13.0)
+  simplecov
+  standard (~> 1.3)
+
+BUNDLED WITH
+   2.4.8

data/README.md

@@ -1,13 +1,13 @@
 ![litestack](https://github.com/oldmoe/litestack/blob/master/assets/litestack_logo_teal_large.png?raw=true)
 
+All your data infrastructure, in a gem!
 
-litestack is a revolutionary gem for Ruby and Ruby on Rails that provides an all-in-one solution for web application development. It exploits the power and embeddedness of SQLite to include a full-fledged SQL database, a fast cache and a robust job queue all in a single package.
+Litestack is a Ruby gem that provides both Ruby and  Ruby on Rails applications an all-in-one solution for web application data infrastructure. It exploits the power and embeddedness of SQLite to deliver a full-fledged SQL database, a fast cache , a robust job queue, a reliable message broker, a full text search engine and a metrics platform all in a single package.
 
-Compared to conventional approaches that require separate servers and databases, Litestack offers superior performance, efficiency, ease of use, and cost savings. Its embedded database and cache reduce memory and CPU usage, while its simple interface streamlines the development process. Overall, LiteStack sets a new standard for web application development and is an excellent choice for those who demand speed, efficiency, and simplicity.
+Compared to conventional approaches that require separate servers and databases, Litestack offers superior performance, efficiency, ease of use, and cost savings. Its embedded database and cache reduce memory and CPU usage, while its simple interface streamlines the development process. Overall, Litestack sets a new standard for web application development and is an excellent choice for those who demand speed, efficiency, and simplicity.
 
 You can read more about why litestack can be a good choice for your next web application **[here](WHYLITESTACK.md)**, you might also be interested in litestack **[benchmarks](BENCHMARKS.md)**.
 
-
 litestack provides integration with popular libraries, including:
 
 - Rack
@@ -24,11 +24,10 @@ With litestack you only need to add a single gem to your app which would replace
 - Cache Server (e.g. Redis, Memcached)
 - Job Processor (e.g. Sidekiq, Goodjob)
 - Pubsub Server (e.g. Redis, PostgreSQL)
+- Fulltext Search Server (e.g. Elasticsearch, Mielisearch)
 
 To make it even more efficient, litestack will detect the presence of Fiber based IO frameworks like Async (e.g. when you use the Falcon web server) or Polyphony. It will then switch its background workers for caches and queues to fibers (using the semantics of the existing framework). This is done transparently and will generally lead to lower CPU and memory utilization.
 
-Litestack is still pretty young and under heavy development, but you are welcome to give it a try today!.
-
 ## Installation
 
 Add the `litestack` gem line to your application's Gemfile:
@@ -41,12 +40,14 @@ To configure a Rails application to run the full litestack, run:
 
 ## Usage
 
-litestack currently offers three main components
+litestack currently offers six main components
 
 - litedb
 - litecache
 - litejob
 - litecable
+- litesearch
+- litemetric
 
 > ![litedb](https://github.com/oldmoe/litestack/blob/master/assets/litedb_logo_teal.png?raw=true)
 
@@ -181,6 +182,119 @@ production:
   adapter: litecable
 ```
 
+> ![litesearch](https://github.com/oldmoe/litestack/blob/master/assets/litesearch_logo_teal.png?raw=true)
+
+### Litesearch
+
+Litesearch adds full text search capabilities to Litedb, you can use it in standalone mode as follows:
+
+```ruby
+require 'litestack/litedb'
+db = Litedb.new(":memory:")
+# create the index
+idx = db.search_index('index_name') do |schema|
+    schema.fields [:sender, :receiver, :body]
+    schema.field :subject, weight: 10
+    schema.tokenizer :trigram
+end
+# add documents
+idx.add({sender: 'Kamal', receiver: 'Laila', subject: 'Are the girls awake?', body: 'I got them the new phones they asked for, are they awake?'})
+# search the index, all fields
+idx.search('kamal')
+# search the index, specific field, partial workd (trigram)
+idx.search('subject: awa') 
+```
+
+Litesearch integrates tightly with ActiveRecord ans Sequel, here are integration examples
+
+#### ActiveRecord
+
+```ruby
+class Author < ActiveRecord::Base
+    has_many :books
+end
+
+class Book < ActiveRecord::Base
+    belongs_to :author
+
+    include Litesearch::Model
+
+    litesearch do |schema|
+        schema.fields [:title, :description]
+        schema.field :author, target: 'authors.name'
+        schema.tokenizer :porter
+    end
+end
+# insert records
+Author.create(name: 'Adam A. Writer') 
+Book.create(title: 'The biggest stunt', author_id: 1, description: 'a description') 
+# search the index, the search method integrates with AR's query interface
+Book.search('author: writer').limit(1).all
+```
+#### Sequel
+
+```ruby
+class Author < Sequel::Model
+    one_to_many :books
+end
+
+class Book < Sequel::Model
+    many_to_one :author
+
+    include Litesearch::Model
+    litesearch do |schema|
+        schema.fields [:title, :description]
+        schema.field :author, target: 'authors.name'
+        schema.tokenizer :porter
+    end
+end
+# insert records
+Author.create(name: 'Adam A. Writer') 
+Book.create(title: 'The biggest stunt', author_id: 1, description: 'a description') 
+# search the index, the search method integrates with Sequel's query interface
+Book.search('author: writer').limit(1).all
+```
+
+> ![litemetric](https://github.com/oldmoe/litestack/blob/master/assets/litemetric_logo_teal.png?raw=true)
+
+### Litemetric
+Litestack comes with a mdoule that can collect useful metrics for its different components, in each component, you need to add the following to the respective .yml file (database.yml in case of Litedb)
+```yml
+    metrics: true # default is false
+```
+If you have the metrics enabled, it will start collecting data from the various modules and will store them in a database file called metric.db located in the Litesupport.root folder
+
+Litemetric has an API that would enable collecting arbitrary metrics for non-litestack classes. The metrics will be in the database but currently the Liteboard is only able to show correct data for Litestack modules, displaying arbitrary metrics for other components will be included later.
+
+### Liteboard
+Liteboard is a simple web server that provides a web interface for the collected metrics, it should be available globally, for usage instructions type
+```
+    liteboard -h
+```
+It allows you to point to a specific metrics database file or a config file and then it will display the data in that metrics database
+
+Example metrics views:
+
+#### Litedb
+![litedb](https://github.com/oldmoe/litestack/blob/master/assets/litedb_metrics.png?raw=true)
+
+- Database size, number of tables & indexes
+- Number of read/write queries
+- Read/Write query ratio over time
+- Read/Write query time over time
+- Slowest queries
+- Most expensive queries (total run time = frequency * cost)
+
+#### Litecache
+![litecache](https://github.com/oldmoe/litestack/blob/master/assets/litecache_metrics.png?raw=true)
+
+- Cache size, % of size limit
+- Number of entries
+- Reads/Writes over time
+- Read hits/misses over time
+- Most written entries
+- Most read entries 
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/oldmoe/litestack.

data/ROADMAP.md

@@ -0,0 +1,45 @@
+# Litestack Roadmap
+
+This is a list of functional/non-functional features that litestack targets to implement on the path to the 1.0 release and beyond
+
+- [ ] Full test coverage
+  - [ ] Litesupport
+  - [ ] Litequeue
+  - [ ] Litejobqueue
+  - [ ] Litejob
+  - [ ] Litejob - Rails
+  - [ ] Litecache
+  - [ ] Litecache - Rails
+  - [ ] Litesearch
+  - [ ] Litesearch - ActiveRecord
+  - [ ] Litesearch - Sequel
+  - [ ] Litemetric
+  - [ ] Litedb
+  - [ ] Litedb - ActiveRecord
+  - [ ] Litedb - Sequel
+- [ ] Github Actions integration
+  - [ ] Automated testing matrix
+  - [ ] Automated gem builds
+- [ ] Litedb improvements
+  - [ ] ActiveRecord Sqlite3 Adapter compatibility mode    
+  - [ ] Sequel Sqlite3 Adapter compatibility mode
+  - [ ] Extension bundling/loading    
+- [ ] Liteiob improvements
+  - [ ] Persist jobs even during execution
+  - [ ] Zombie job detection
+  - [ ] Better process exit handling 
+  - [ ] Faster job dispatch for the no delay case
+- [ ] Database maintenance scripts
+  - [ ] Online backup
+  - [ ] Restore
+  - [ ] Litestream integration
+  - [ ] CoW filesystems specific backup path
+- [ ] Zero downtime deployment scripts
+  - [ ] Rails
+  - [ ] Genereic Rack Applications
+- [ ] Litemetric improvements
+  - [ ] Rails performance module
+  - [ ] Ruby Memory/GC module
+  - [ ] Restore generic module
+  - [ ] Better HTML/CSS
+- [ ] Kredis replacement implementation?    

data/Rakefile

@@ -9,4 +9,6 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList["test/**/test_*.rb"]
 end
 
-task default: :test
+require "standard/rake"
+
+task default: %i[test standard]

data/WHYLITESTACK.md

@@ -5,7 +5,7 @@ If you're developing a Ruby web application, you may be wondering which database
 ## Standing on the shoulder of a (figurative) giant!
 At its core, Litestack is built on top of SQLite, a highly regarded open-source relational database engine. This means that Litestack is highly efficient and resource-friendly, making it an excellent choice for small to medium-sized web applications. Additionally, because SQLite is a file-based database, it is incredibly easy to set up and manage, requiring no separate server installation or configuration.
 
-## Performance and Effeciency
+## Performance and Efficiency
 One of the most significant advantages of Litestack is its performance benefits. SQLite has a small memory footprint and is highly optimized, meaning that it can deliver fast and reliable database access. Additionally, Litestack's job queueing and caching functionality provide additional performance benefits, enabling you to execute tasks asynchronously and store frequently accessed data in memory for faster access.
 
 ## Dead simple Rails integration

data/bench/bench.rb

@@ -1,23 +1,30 @@
-require 'sqlite3'
+require "sqlite3"
 
-def bench(msg, iterations=1000)
+def bench(msg, iterations = 1000)
   GC.start
-  #GC.compact
-  STDERR.puts "Starting #{iterations} iterations of #{msg} ... "
+  # GC.compact
+  warn "Starting #{iterations} iterations of #{msg} ... "
   t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
   iterations.times do |i|
     yield i
   end
   t2 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-  time = ((t2 - t1)*1000).to_i.to_f / 1000 rescue 0
-  ips = ((iterations/(t2-t1))*100).to_i.to_f / 100 rescue "infinity?"
-  #{m: msg, t: time, ips: iteratinos/time, i: iterations}
- STDERR.puts " .. finished in #{time} seconds (#{ips} ips)"
+  time = begin
+    ((t2 - t1) * 1000).to_i.to_f / 1000
+  rescue
+    0
+  end
+  ips = begin
+    ((iterations / (t2 - t1)) * 100).to_i.to_f / 100
+  rescue
+    "infinity?"
+  end
+  # {m: msg, t: time, ips: iteratinos/time, i: iterations}
+  warn " .. finished in #{time} seconds (#{ips} ips)"
 end
 
 @db = SQLite3::Database.new(":memory:") # sqlite database for fast random string generation
 
 def random_str(size)
   @db.get_first_value("select hex(randomblob(?))", size)
-end 
-
+end

data/bench/bench_cache_rails.rb

@@ -1,11 +1,11 @@
-require 'active_support'
-require_relative '../lib/litestack'
-require_relative './bench'
+require "active_support"
+require_relative "../lib/litestack"
+require_relative "./bench"
 
-cache = ActiveSupport::Cache::Litecache.new({path: '../db/rails_cache.db'})
+cache = ActiveSupport::Cache::Litecache.new({path: "../db/rails_cache.db"})
 
-#can only use the lookup method when the gem is installed
-#cache = ActiveSupport::Cache.lookup_store(:litecache, {path: '../db/rails_cache.db'})
+# can only use the lookup method when the gem is installed
+# cache = ActiveSupport::Cache.lookup_store(:litecache, {path: '../db/rails_cache.db'})
 
 redis = ActiveSupport::Cache.lookup_store(:redis_cache_store, {})
 
@@ -15,10 +15,10 @@ count = 1000
 
 [10, 100, 1000, 10000].each do |size|
   count.times do
-    keys << random_str(10) 
-    values << random_str(size) 
+    keys << random_str(10)
+    values << random_str(size)
   end
-  
+
   random_keys = keys.shuffle
   puts "Benchmarks for values of size #{size} bytes"
   puts "=========================================================="
@@ -41,12 +41,10 @@ count = 1000
   end
   puts "=========================================================="
 
-
   keys = []
   values = []
 end
 
-
 cache.write("somekey", 1, raw: true)
 
 redis.write("somekey", 1, raw: true)
@@ -59,9 +57,8 @@ bench("litecache increment", count) do
 end
 
 bench("Redis increment", count) do
-  redis.increment("somekey", 1, raw: true )
+  redis.increment("somekey", 1, raw: true)
 end
 
 cache.clear
 redis.clear
-

data/bench/bench_cache_raw.rb

@@ -1,17 +1,17 @@
-require 'redis'
-require 'sqlite3'
-require_relative './bench'
+require "redis"
+require "sqlite3"
+require_relative "./bench"
 
-#require 'polyphony'
-require 'async/scheduler'
+# require 'polyphony'
+require "async/scheduler"
 
 Fiber.set_scheduler Async::Scheduler.new
 Fiber.scheduler.run
 
-require_relative '../lib/litestack/litecache'
-#require 'litestack'
+require_relative "../lib/litestack/litecache"
+# require 'litestack'
 
-cache = Litecache.new({path: '../db/cache.db'}) # default settings
+cache = Litecache.new({path: "../db/cache.db"}) # default settings
 redis = Redis.new # default settings
 
 values = []
@@ -21,13 +21,13 @@ count.times { keys << random_str(10) }
 
 [10, 100, 1000, 10000].each do |size|
   count.times do
-    values << random_str(size) 
+    values << random_str(size)
   end
-  
+
   random_keys = keys.shuffle
-  
+
   GC.compact
-  
+
   puts "Benchmarks for values of size #{size} bytes"
   puts "=========================================================="
   puts "== Writes =="
@@ -35,12 +35,11 @@ count.times { keys << random_str(10) }
     cache.set(keys[i], values[i])
   end
 
-  #bench("file writes", count) do |i|
+  # bench("file writes", count) do |i|
   #  f = File.open("../files/#{keys[i]}.data", 'w+')
   #  f.write(values[i])
   #  f.close
-  #end
-  
+  # end
 
   bench("Redis writes", count) do |i|
     redis.set(keys[i], values[i])
@@ -51,9 +50,9 @@ count.times { keys << random_str(10) }
     cache.get(random_keys[i])
   end
 
-  #bench("file reads", count) do |i|
+  # bench("file reads", count) do |i|
   #  data = File.read("../files/#{keys[i]}.data")
-  #end
+  # end
 
   bench("Redis reads", count) do |i|
     redis.get(random_keys[i])
@@ -61,11 +60,8 @@ count.times { keys << random_str(10) }
   puts "=========================================================="
 
   values = []
-  
-  
 end
 
-
 cache.set("somekey", 1)
 redis.set("somekey", 1)
 
@@ -80,5 +76,4 @@ end
 cache.clear
 redis.flushdb
 
-#sleep
-
+# sleep