litestack 0.1.7 → 0.2.0

data/lib/litestack/litemetric.rb

@@ -0,0 +1,228 @@
+# frozen_stringe_literal: true
+
+require 'singleton'
+
+require_relative './litesupport'
+
+# this class is a singleton
+# and should remain so
+class Litemetric
+
+  include Singleton
+  include Litesupport::Liteconnection
+  
+  DEFAULT_OPTIONS = {
+    config_path: "./litemetric.yml",
+    path: "./metrics.db",
+    sync: 1,
+    mmap_size: 16 * 1024 * 1024, # 16MB of memory to easily process 1 year worth of data
+    flush_interval: 10, # flush data every 1 minute
+    summarize_interval: 10 # summarize data every 1 minute
+  }
+
+  RESOLUTIONS = {
+    minute: 300, # 5 minutes (highest resolution)
+    hour: 3600, # 1 hour
+    day: 24*3600, # 1 day
+    week: 7*24*3600 # 1 week (lowest resolution)
+  }
+
+  # :nodoc: 
+  def initialize(options = {})
+    init(options)
+  end
+  
+  # registers a class for metrics to be collected
+  def register(identifier)
+    @registered[identifier] = true   
+    @metrics[identifier] = {} unless @metrics[identifier]
+    run_stmt(:register_topic, identifier) # it is safe to call register topic multiple times with the same identifier
+  end
+  
+  ## event capturing
+  ##################
+    
+  def capture(topic, event, key=event, value=nil)
+    if key.is_a? Array
+      key.each{|k| capture_single_key(topic, event, k, value)}
+    else
+      capture_single_key(topic, event, key, value)
+    end
+  end
+  
+  def capture_single_key(topic, event, key=event, value=nil)
+    @mutex.synchronize do
+      time_slot = current_time_slot # should that be 5 minutes?
+      topic_slot = @metrics[topic]
+      if event_slot = topic_slot[event]
+        if key_slot = event_slot[key]
+          if key_slot[time_slot]
+            key_slot[time_slot][:count] += 1
+            key_slot[time_slot][:value] += value unless value.nil?
+          else # new time slot
+            key_slot[time_slot] = {count: 1, value: value}
+          end
+        else
+          event_slot[key] = {time_slot => {count: 1, value: value}}
+        end
+      else # new event
+        topic_slot[event] = {key => {time_slot => {count: 1, value: value}}}
+      end
+    end
+  end
+  
+
+  ## event reporting
+  ##################
+  
+  def topics
+    run_stmt(:list_topics).to_a
+  end
+
+  def event_names(resolution, topic)
+    run_stmt(:list_event_names, resolution, topic).to_a
+  end
+
+  def keys(resolution, topic, event_name)
+    run_stmt(:list_event_keys, resolution, topic, event_name).to_a
+  end
+
+  def event_data(resolution, topic, event_name, key)
+    run_stmt(:list_events_by_key, resolution, topic, event_name, key).to_a
+  end
+  
+  ## summarize data
+  #################  
+
+  def summarize
+    run_stmt(:summarize_events, RESOLUTIONS[:hour], "hour", "minute") 
+    run_stmt(:summarize_events, RESOLUTIONS[:day], "day", "hour") 
+    run_stmt(:summarize_events, RESOLUTIONS[:week], "week", "day")
+    run_stmt(:delete_events, "minute", RESOLUTIONS[:hour]*1) 
+    run_stmt(:delete_events, "hour", RESOLUTIONS[:day]*1) 
+    run_stmt(:delete_events, "day", RESOLUTIONS[:week]*1) 
+  end
+
+  ## background stuff
+  ###################
+
+  private
+
+  def exit_callback
+    puts "--- Litemetric detected an exit, flushing metrics"
+    @running = false
+    flush
+  end
+
+  def setup
+    super
+    @metrics = {}
+    @registered = {}
+    @flusher = create_flusher
+    @summarizer = create_summarizer
+    @mutex = Litesupport::Mutex.new
+  end
+
+  def current_time_slot
+    (Time.now.to_i / 300) * 300 # every 5 minutes 
+  end
+  
+  def flush
+    to_delete = []
+    @conn.acquire do |conn|
+      conn.transaction(:immediate) do
+        @metrics.each_pair do |topic, event_hash|
+          event_hash.each_pair do |event, key_hash|
+            key_hash.each_pair do |key, time_hash|
+              time_hash.each_pair do |time, data|
+                conn.stmts[:capture_event].execute!(topic, event.to_s, key, time, data[:count], data[:value]) if data 
+                time_hash[time] = nil 
+                to_delete << [topic, event, key, time]
+              end
+            end      
+          end      
+        end
+      end
+    end
+    to_delete.each do |r| 
+      @metrics[r[0]][r[1]][r[2]].delete(r[3])
+      @metrics[r[0]][r[1]].delete(r[2]) if @metrics[r[0]][r[1]][r[2]].empty? 
+      @metrics[r[0]].delete(r[1]) if @metrics[r[0]][r[1]].empty? 
+    end
+  end  
+     
+  def create_connection
+    conn = super
+    conn.wal_autocheckpoint = 10000
+    sql = YAML.load_file("#{__dir__}/litemetric.sql.yml")
+    version = conn.get_first_value("PRAGMA user_version")
+    sql["schema"].each_pair do |v, obj| 
+      if v > version
+        conn.transaction do 
+          obj.each{|k, s| conn.execute(s)}
+          conn.user_version = v
+        end
+      end
+    end 
+    sql["stmts"].each { |k, v| conn.stmts[k.to_sym] = conn.prepare(v) }
+    conn
+  end
+  
+  def create_flusher
+    Litesupport.spawn do
+      while @running do
+        sleep @options[:flush_interval]
+        @mutex.synchronize do
+          flush
+        end
+      end      
+    end 
+  end
+  
+  def create_summarizer
+    Litesupport.spawn do
+      while @running do
+        sleep @options[:summarize_interval]
+        summarize
+      end      
+    end 
+  end
+       
+end
+
+## Measurable Module
+####################
+
+class Litemetric
+  module Measurable
+            
+    def collect_metrics
+      @litemetric = Litemetric.instance
+      @litemetric.register(metrics_identifier)
+    end
+
+    def metrics_identifier
+      self.class.name # override in included classes
+    end
+
+    def capture(event, key=event, value=nil)
+      return unless @litemetric
+      @litemetric.capture(metrics_identifier, event, key, value)
+    end
+    
+    def measure(event, key=event)
+      return yield unless @litemetric
+      t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC) 
+      res = yield
+      t2 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      value = (( t2 - t1 ) * 1000).round # capture time in milliseconds
+      capture(event, key, value)
+      res  
+    end    
+    
+    def snapshot
+      raise Litestack::NotImplementedError
+    end
+    
+  end
+end

data/lib/litestack/litemetric.sql.yml

@@ -0,0 +1,69 @@
+schema:
+  1:
+    create_topics: >
+      CREATE TABLE IF NOT EXISTS topics(
+        name text PRIMARY KEY NOT NULL
+      ) WITHOUT ROWID; 
+    create_events: >
+      CREATE TABLE IF NOT EXISTS events(
+        topic text NOT NULL references topics(name) ON DELETE CASCADE, 
+        name TEXT NOT NULL, 
+        key TEXT NOT NULL, 
+        count INTEGER DEFAULT(0) NOT NULL ON CONFLICT REPLACE, 
+        value INTEGER, 
+        minimum INTEGER, 
+        maximum INTEGER, 
+        created_at INTEGER DEFAULT((unixepoch()/300*300)) NOT NULL, 
+        resolution TEXT DEFAULT('minute') NOT NULL, 
+        PRIMARY KEY(resolution, topic, name, key, created_at)
+      ) WITHOUT ROWID;    
+    create_index_on_event: CREATE INDEX IF NOT EXISTS events_by_resolution ON events(resolution, created_at);
+
+stmts:
+  # register topic
+  register_topic: INSERT INTO topics VALUES (?) ON CONFLICT DO NOTHING;
+
+  capture_event: >
+    INSERT INTO events(topic, name, key, created_at, count, value, minimum, maximum) VALUES ($1, $2, $3, $4, $5, $6, $6, $6) 
+    ON CONFLICT DO 
+    UPDATE SET count = count + EXCLUDED.count, value = value + EXCLUDED.value, minimum = min(minimum, EXCLUDED.minimum), maximum = max(maximum, EXCLUDED.maximum) 
+  
+  # requires an index on (resolution, created_at)
+  summarize_events: >
+    INSERT INTO events (topic, name, key, count, value, minimum, maximum, created_at, resolution ) SELECT 
+      topic, 
+      name, 
+      key, 
+      sum(count) as count, 
+      sum(value) as value, 
+      min(minimum) as minimum, 
+      max(maximum) as maximum, 
+      (created_at/$1)*$1 as created,  
+      $2 
+    FROM events WHERE resolution = $3 AND created_at < (unixepoch()/$1)*$1 GROUP BY topic, name, key, created ON CONFLICT DO UPDATE 
+    SET count = count + EXCLUDED.count, value = value + EXCLUDED.value, minimum = min(minimum, EXCLUDED.minimum), maximum = max(maximum, EXCLUDED.maximum); 
+
+  # requires an index on (resolution, created_at)
+  delete_events: DELETE FROM events WHERE resolution = $3 AND created_at < (unixepoch() - $4);
+
+  # select topics from the topics table
+  list_topics: SELECT name FROM topics;
+
+  # requires an index on (resolution, topic, name)
+  list_event_names: >
+    SELECT name, sum(count) as count, count(distinct name) as name, sum(value) as value, min(minimum), max(maximum) 
+    FROM events WHERE resolution = ? AND topic = ? GROUP BY name ORDER BY count;
+
+  # requires an index on (resolution, topic, name, key)
+  list_event_keys: >
+    SELECT key, sum(count) as count, sum(value) as value, min(minimum), max(maximum)
+    FROM events WHERE resolution = ? AND topic = ? AND name = ? GROUP BY key ORDER BY count;
+  
+  # requires an index on (resolution, topic, name, key, created_at)
+  list_events_by_key: > 
+    SELECT * FROM events WHERE resolution = $1 AND topic = $2 AND name = $3 AND key = $4 ORDER BY created_at ASC;    
+    
+  # requires an index on (resolution, topic, name, key, created_at)
+  list_all_events: >
+    SELECT * FROM events WHERE resolution = ? AND topic = ? ORDER BY name, key, created_at ASC;
+ 

data/lib/litestack/litequeue.rb

@@ -3,6 +3,8 @@
 # all components should require the support module
 require_relative 'litesupport'
 
+#require 'securerandom'
+
 ##
 #Litequeue is a simple queueing system for Ruby applications that allows you to push and pop values from a queue. It provides a straightforward API for creating and managing named queues, and for adding and removing values from those queues. Additionally, it offers options for scheduling pops at a certain time in the future, which can be useful for delaying processing until a later time.
 #
@@ -18,10 +20,12 @@ class Litequeue
   #   mmap_size: 128 * 1024 * 1024 -> 128MB to be held in memory
   #   sync: 1 -> sync only when checkpointing
   
+  include Litesupport::Liteconnection
+  
   DEFAULT_OPTIONS = {
     path: "./queue.db",
     mmap_size: 32 * 1024,
-    sync: 1
+    sync: 0
   }
 
   # create a new instance of the litequeue object
@@ -33,8 +37,7 @@ class Litequeue
   #   queue.pop # => "somevalue"
   
   def initialize(options = {})
-    @options = DEFAULT_OPTIONS.merge(options)
-    @queue = Litesupport::Pool.new(1){create_db} # delegate the db creation to the litepool
+    init(options)
   end
    
   # push an item to the queue, optionally specifying the queue name (defaults to default) and after how many seconds it should be ready to pop (defaults to zero)
@@ -45,17 +48,23 @@ class Litequeue
     # also bring back the synchronize block, to prevent
     # a race condition if a thread hits the busy handler
     # before the current thread proceeds after a backoff
-    result = @queue.acquire { |q| q.stmts[:push].execute!(queue, delay, value)[0] }
-    return result[0] if result
+    #id = SecureRandom.uuid # this is somehow expensive, can we improve?
+    run_stmt(:push, queue, delay, value)[0]
+  end
+  
+  def repush(id, value, delay=0, queue='default')
+    run_stmt(:repush, id, queue, delay, value)[0]
   end
   
   alias_method :"<<", :push
+  alias_method :"<<<", :repush
   
   # pop an item from the queue, optionally with a specific queue name (default queue name is 'default')
   def pop(queue='default', limit = 1)
-   res = @queue.acquire {|q| res = q.stmts[:pop].execute!(queue, limit)[0] }
-   #return res[0] if res.length == 1
-   #res
+   res = run_stmt(:pop, queue, limit)
+   return res[0] if res.length == 1
+   return nil if res.empty?
+   res
   end
   
   # delete an item from the queue
@@ -63,42 +72,61 @@ class Litequeue
   #   id = queue.push("somevalue")
   #   queue.delete(id) # => "somevalue"
   #   queue.pop # => nil
-  def delete(id, queue='default')
-    fire_at, id = id.split("_")
-    result = @queue.acquire{|q| q.stmts[:delete].execute!(queue, fire_at.to_i, id)[0] } 
+  def delete(id)
+    result = run_stmt(:delete, id)[0]  
   end
   
   # deletes all the entries in all queues, or if a queue name is given, deletes all entries in that specific queue
   def clear(queue=nil)
-    @queue.acquire{|q| q.execute("DELETE FROM _ul_queue_ WHERE iif(?, queue = ?,  1)", queue) }
+    run_sql("DELETE FROM queue WHERE iif(?, name = ?,  1)", queue)
   end
 
   # returns a count of entries in all queues, or if a queue name is given, reutrns the count of entries in that queue
   def count(queue=nil)
-    @queue.acquire{|q| q.get_first_value("SELECT count(*) FROM _ul_queue_ WHERE iif(?, queue = ?, 1)", queue) }
+    run_sql("SELECT count(*) FROM queue WHERE iif(?, name = ?, 1)", queue)[0][0]
   end
   
   # return the size of the queue file on disk
   def size
-    @queue.acquire{|q| q.get_first_value("SELECT size.page_size * count.page_count FROM pragma_page_size() AS size, pragma_page_count() AS count") }
+    run_sql("SELECT size.page_size * count.page_count FROM pragma_page_size() AS size, pragma_page_count() AS count")[0][0] 
   end
-
-  private  
   
-  def create_db
-    db = Litesupport.create_db(@options[:path])
-    db.synchronous = @options[:sync]
-    db.wal_autocheckpoint = 10000 
-    db.mmap_size = @options[:mmap_size]
-    db.execute("CREATE TABLE IF NOT EXISTS _ul_queue_(queue TEXT DEFAULT('default') NOT NULL ON CONFLICT REPLACE, fire_at INTEGER DEFAULT(unixepoch()) NOT NULL ON CONFLICT REPLACE, id TEXT DEFAULT(hex(randomblob(8)) || (strftime('%f') * 100)) NOT NULL ON CONFLICT REPLACE, value TEXT, created_at INTEGER DEFAULT(unixepoch()) NOT NULL ON CONFLICT REPLACE, PRIMARY KEY(queue, fire_at ASC, id) ) WITHOUT ROWID")
-    db.stmts[:push] = db.prepare("INSERT INTO _ul_queue_(queue, fire_at, value) VALUES ($1, (strftime('%s') + $2), $3) RETURNING fire_at || '-' || id")
-    db.stmts[:pop] = db.prepare("DELETE FROM _ul_queue_ WHERE (queue, fire_at, id) IN (SELECT queue, fire_at, id FROM _ul_queue_ WHERE queue = ifnull($1, 'default') AND fire_at <= (unixepoch()) ORDER BY fire_at ASC LIMIT ifnull($2, 1)) RETURNING fire_at || '-' || id, value")
-    db.stmts[:delete] = db.prepare("DELETE FROM _ul_queue_ WHERE queue = ifnull($1, 'default') AND fire_at = $2 AND id = $3 RETURNING value")
-    db
+  def queues_info
+    run_sql("SELECT name, count(*) AS count, avg(unixepoch() - created_at), min(unixepoch() - created_at), max(unixepoch() - created_at) FROM queue GROUP BY name ORDER BY count DESC ")
+  end
+  
+  def info
+    counts = {}
+    queues_info.each do |qc|
+      counts[qc[0]] = {count: qc[1], time_in_queue: {avg: qc[2], min: qc[3], max: qc[4]}}
+    end
+    {size: size, count: count, info: counts}
   end
 
+  private  
+      
+  def create_connection
+    conn = super
+    conn.wal_autocheckpoint = 10000 
+    sql = YAML.load_file("#{__dir__}/litequeue.sql.yml")
+    version = conn.get_first_value("PRAGMA user_version")
+    sql["schema"].each_pair do |v, obj| 
+      if v > version
+        conn.transaction(:immediate) do 
+          obj.each{|k, s| conn.execute(s)}
+          conn.user_version = v
+        end
+      end
+    end 
+    sql["stmts"].each { |k, v| conn.stmts[k.to_sym] = conn.prepare(v) }
+    # check if there is an old database and convert entries to the new format
+    if conn.get_first_value("select count(*) from sqlite_master where name = '_ul_queue_'") == 1
+      conn.transaction(:immediate) do
+        conn.execute("INSERT INTO queue(fire_at, name, value, created_at) SELECT fire_at, queue, value, created_at FROM _ul_queue_")
+        conn.execute("DROP TABLE _ul_queue_")
+      end
+    end
+    conn
+  end
 
 end  
-
-
-

data/lib/litestack/litequeue.sql.yml

@@ -0,0 +1,34 @@
+schema:
+  1:    
+    create_table_queue: >  
+      CREATE TABLE IF NOT EXISTS queue(
+        id TEXT PRIMARY KEY DEFAULT(hex(randomblob(32))) NOT NULL ON CONFLICT REPLACE, 
+        name TEXT DEFAULT('default') NOT NULL ON CONFLICT REPLACE, 
+        fire_at INTEGER DEFAULT(unixepoch()) NOT NULL ON CONFLICT REPLACE,
+        value TEXT,
+        created_at INTEGER DEFAULT(unixepoch()) NOT NULL ON CONFLICT REPLACE
+      ) WITHOUT ROWID 
+      
+    create_index_queue_by_name: >
+      CREATE INDEX IF NOT EXISTS idx_queue_by_name ON queue(name, fire_at ASC)
+
+stmts:
+
+  push: INSERT INTO queue(id, name, fire_at, value) VALUES (hex(randomblob(32)), $1, (unixepoch() + $2), $3) RETURNING id, name
+  
+  repush: INSERT INTO queue(id, name, fire_at, value) VALUES (?, ?, (unixepoch() + ?), ?) RETURNING name 
+
+  pop: >
+    DELETE FROM queue 
+    WHERE (name, fire_at, id) 
+    IN (
+        SELECT name, fire_at, id FROM queue 
+        WHERE name = ifnull($1, 'default') 
+        AND fire_at <= (unixepoch()) 
+        ORDER BY fire_at ASC 
+        LIMIT ifnull($2, 1)
+    ) 
+    RETURNING id, value
+  
+  delete: DELETE FROM queue WHERE id = $1 RETURNING value
+

data/lib/litestack/litesupport.rb

@@ -1,5 +1,9 @@
+# frozen_stringe_literal: true
+
 require 'sqlite3'
-require 'hiredis'
+require 'logger'
+require 'oj'
+require 'yaml'
 
 module Litesupport
 
@@ -38,8 +42,8 @@ module Litesupport
     end
     # we should never reach here
   end
-  
-  def self.detect_context
+    
+  def self.context
     if environment == :fiber || environment == :poylphony
       Fiber.current.storage
     else
@@ -47,8 +51,12 @@ module Litesupport
     end
   end
   
-  def self.context
-    @ctx ||= detect_context
+  def self.current_context
+    if environment == :fiber || environment == :poylphony
+      Fiber.current
+    else
+      Thread.current
+    end
   end
   
   # switch the execution context to allow others to run
@@ -87,7 +95,7 @@ module Litesupport
   # common db object options
   def self.create_db(path)
     db = SQLite3::Database.new(path)
-    db.busy_handler{ switch || sleep(0.001) }
+    db.busy_handler{ switch || sleep(0.0001) }
     db.journal_mode = "WAL"
     db.instance_variable_set(:@stmts, {})
     class << db
@@ -111,6 +119,21 @@ module Litesupport
     end
   
   end
+   
+  module Forkable
+    
+    def _fork(*args)
+      ppid = Process.pid
+      result = super      
+      if Process.pid != ppid
+        # trigger a restart of all connections owned by Litesupport::Pool
+      end
+      result
+    end
+    
+  end
+
+  #::Process.singleton_class.prepend(::Litesupport::Forkable)
   
   class Pool
   
@@ -126,6 +149,7 @@ module Litesupport
     end
     
     def acquire
+      # check for pid changes
       acquired = false
       result = nil
       while !acquired do
@@ -148,5 +172,130 @@ module Litesupport
     end
     
   end
+     
+  module ForkListener
+    def self.listeners
+      @listeners ||= []
+    end
+    
+    def self.listen(&block)
+      listeners << block
+    end
+  end
+
+  module Forkable
+      
+    def _fork(*args)
+      ppid = Process.pid
+      result = super
+      if Process.pid != ppid && [:threaded, :iodine].include?(Litesupport.environment)
+        ForkListener.listeners.each{|l| l.call }
+      end
+      result
+    end
+    
+  end
   
+  module Liteconnection
+    
+    include Forkable
+
+    # close, setup, run_stmt and run_sql assume a single connection was created
+    def close
+      @running = false
+      @conn.acquire do |q| 
+        q.stmts.each_pair {|k, v| q.stmts[k].close }
+        q.close
+      end
+    end
+
+    private # all methods are private
+        
+    def init(options = {})
+      #c configure the object, loading options from the appropriate location
+      configure(options)    
+      # setup connections and background threads
+      setup      
+      # handle process exiting
+      at_exit do 
+        exit_callback
+      end
+      # handle forking (restart connections and background threads)
+      Litesupport::ForkListener.listen do
+        setup
+      end
+    end  
+    
+    def configure(options = {})
+      # detect environment (production, development, etc.)
+      env = "development"
+      if defined? Rails
+        env = ENV["RAILS_ENV"]
+      elsif ENV["RACK_ENV"]
+        env = ENV["RACK_ENV"]  
+      elsif ENV["APP_ENV"]
+        env = ENV["RACK_ENV"]
+      end      
+      defaults = self.class::DEFAULT_OPTIONS rescue {}
+      @options = defaults.merge(options)
+      config = YAML.load_file(@options[:config_path]) rescue {} # an empty hash won't hurt
+      config = config[env] if config[env] # if there is a config for the current environment defined then use it, otherwise use the top level declaration
+      config.keys.each do |k| # symbolize keys
+        config[k.to_sym] = config[k]
+        config.delete k
+      end
+      @options.merge!(config)
+      @options.merge!(options) # make sure options passed to initialize trump everything else
+    end
+    
+    def setup
+      @conn = create_pooled_connection
+      @logger = create_logger
+      @running = true
+    end
+    
+    def create_logger
+      @options[:logger] = nil unless @options[:logger]
+      return @options[:logger] if @options[:logger].respond_to? :info
+      return Logger.new(STDOUT) if @options[:logger] == 'STDOUT'
+      return Logger.new(STDERR) if @options[:logger] == 'STDERR'
+      return Logger.new(@options[:logger]) if @options[:logger].is_a? String 
+      return Logger.new(IO::NULL)         
+    end
+    
+    def exit_callback
+      close
+    end
+
+    def run_stmt(stmt, *args)
+      @conn.acquire{|q| q.stmts[stmt].execute!(*args) }
+    end
+
+    def run_sql(sql, *args)
+      @conn.acquire{|q| q.execute(sql, *args) }
+    end
+    
+    def create_pooled_connection(count = 1)
+      Litesupport::Pool.new(1){create_connection}  
+    end
+
+    # common db object options
+    def create_connection
+      conn = SQLite3::Database.new(@options[:path])
+      conn.busy_handler{ Litesupport.switch || sleep(rand * 0.002) }
+      conn.journal_mode = "WAL"
+      conn.synchronous = @options[:sync] || 1
+      conn.mmap_size = @options[:mmap_size] || 0
+      conn.instance_variable_set(:@stmts, {})
+      class << conn
+        attr_reader :stmts
+      end
+      conn
+    end
+    
+  end
+      
 end  
+
+Process.singleton_class.prepend(Litesupport::Forkable)
+

data/lib/litestack/metrics_app.rb

@@ -0,0 +1,5 @@
+require_relative '../lib/litestack/litemetrics'
+
+metric = Litemetrics.instance
+
+puts metric.ids

data/lib/litestack/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Litestack
-  VERSION = "0.1.7"
+  VERSION = "0.2.0"
 end