tobias 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f62ad896d11551538f57fe41808b243b3484b99e6271ce3aa33610794a71c96
-  data.tar.gz: f7bd71569888157686b8a3f605ea7be8286d3967197789a55b5dc45f361f9170
+  metadata.gz: 4b50326ed51ec5388f5f63528cbfe0cda2f27db4e505b0cdf1349f1cc9313311
+  data.tar.gz: e76ddcd08800005f89ddb772953df045ad623fcfc13e114090bdfcdd49c0dabb
 SHA512:
-  metadata.gz: f678080160f435018f4a2c4e867e0363ef4e386fed008b94542ca3a369a19f25e4ce718bf49e1e8cc24c12b5a7b12a0071395ab94128d8573c56af52abcdbae7
-  data.tar.gz: 7cc8e7b73904fcf7dce92dcae85cc5f338c96ae0a7e52ae80b519c5d1cf1875450e3fdaf062e09c905dd52073efb889751e63ebba62343ce30a5fac64964d16d
+  metadata.gz: 456a7a52310fcac42a5755ad02aeb464bb429742888a195569fb5d5df7f33416d583cef442eca92b035af9807e7ec5d17c626b0eda20b9d43998fc4c99ccb6f3
+  data.tar.gz: e8c5d112db7cd2e87f37455d90b25a6dfe53eba27e60a492c4fbc4798a941bdc9b69532b813eb39f4c69b68c34812e09112ec19a80485f90e526869e2d0c1794

data/lib/tobias/cli.rb

@@ -10,10 +10,11 @@ module Tobias
 
     desc "profile SCRIPT", "profile"
     option :database_url, type: :string, required: true
-    option :iterations, type: :numeric, default: 100
+    option :iterations, type: :numeric, default: 10
+    option :debug, type: :boolean, default: false
     def profile(script)
       database = Sequel.connect(options[:database_url])
-      database.loggers << Logger.new(nil)
+      database.loggers << Logger.new(STDERR) if options[:debug]
       database.extension :pg_json
 
       if File.exist?(script)
@@ -22,54 +23,30 @@ module Tobias
         raise "Script not found at: #{script}"
       end
 
-      WorkMem.all.each do |value|
-        database.transaction do
-          database.run("SET LOCAL work_mem = '#{value.to_sql}'")
+      container = Container.new(code)
+      results = {}
 
-          eval(code, binding, script)
+      parsed = TTY::Markdown.parse(<<~MARKDOWN)
+        # @tobias is thinking...
+      MARKDOWN
+      puts parsed
 
-          @queries.each do |name, block|
-            database.select(Sequel.function(:pg_stat_reset)).first
-
-            query = instance_eval(&block)
-            times = []
-
-            options[:iterations].to_i.times do
-              time = Benchmark.realtime do
-                database.run(query.sql)
-              end
-              times << time
-            end
+      thinking_time = Benchmark.realtime do
+        results = Evaluations.run(database, container, options)
+      end
 
-            stats = database[:pg_stat_database].where(datname: Sequel.function(:current_database)).first
+      parsed = TTY::Markdown.parse(<<~MARKDOWN)
+        # @tobias has sent you a new message
 
-            puts "--------------------------------"
-            puts "query: #{name}"
-            puts "work_mem: #{value.to_sql}"
-            puts "clock time (mean): #{times.mean.round(2)}"
-            puts "clock time (95%): #{times.percentile(95).round(2)}"
+        I thought about your queries for precisely #{thinking_time.round(2)} seconds and here is what I recommend:
 
-            if stats[:temp_files] > 0 || stats[:temp_bytes] > 0
-              puts "Not enough work_mem"
-              puts "temp_files: #{stats[:temp_files]}"
-              puts "temp_bytes: #{stats[:temp_bytes]}"
-            else
-              puts "No temporary files written."
-              puts "Current work_mem: '#{value.to_sql}' is sufficient."
-              return
-            end
-            puts "--------------------------------"
-          end
-        end
-      end
-    end
+        #{results.join("\n")}
 
-    private
+        Regards,
+        ~ Tobias
+      MARKDOWN
 
-    def query(name, &block)
-      @queries ||= {}
-      @queries[name] = block
+      puts parsed
     end
-
   end
 end

data/lib/tobias/container.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Tobias
+  class Container
+    def initialize(code)
+      @code = code
+      @queries = {}
+
+      eval(code, binding, __FILE__, __LINE__)
+    end
+
+    def queries
+      @queries
+    end
+
+    def query(name, &block)
+      @queries[name] = block
+    end
+  end
+end

data/lib/tobias/evaluations/base.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Tobias
+  module Evaluations
+    class Base
+      attr_reader :database, :container
+
+      def initialize(database, container)
+        @database = database
+        @container = container
+      end
+
+      def run(options, &block)
+        results = {}
+
+        container.queries.each do |name, query|
+          results.merge!(run_each(name, query, options))
+        end
+
+        to_markdown(results)
+      end
+
+      def run_each(query, options)
+        raise NotImplementedError
+      end
+
+      def to_markdown(results)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/tobias/evaluations/work_mem.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Tobias
+  module Evaluations
+    class WorkMem < Base
+
+      def work_mems
+        Tobias::WorkMem.valid_for(database)
+      end
+
+      def description
+        "Optional work_mem settings"
+      end
+
+      def run_each(name, query, options)
+        work_mems.each do |value|
+          database.transaction do
+            database.run("CREATE EXTENSION IF NOT EXISTS pg_stat_statements")
+            database.run("SET LOCAL work_mem = '#{value.to_sql}'")
+            database.select(Sequel.function(:pg_stat_reset)).first
+
+            query_result = database.instance_eval(&query)
+            options[:iterations].to_i.times do
+              database.run(query_result.sql)
+            end
+
+            stats = database[:pg_stat_database].where(datname: Sequel.function(:current_database)).first
+
+            if stats[:temp_files] == 0 && stats[:temp_bytes] == 0
+              return { name => value }
+            end
+          end
+        end
+
+        # TODO: Add a warning message or something.
+        return { name => nil }
+      end
+
+      def to_markdown(results)
+        current_work_mem = Tobias::WorkMem.from_sql(database.fetch("SHOW work_mem").first[:work_mem])
+
+        <<~MARKDOWN
+          ## #{description}
+
+          | Query | Required work_mem |
+          |-------|-------------------|
+          #{results.map { |name, work_mem| "| #{name} | #{work_mem.to_sql} |" }.join("\n")}
+
+          Your application will need to run with at least #{results.values.max.to_sql} of work_mem.
+
+          I see that your current work_mem setting is #{current_work_mem.to_sql}.
+
+          To apply my recommendations, run the following SQL:
+
+          ```sql
+          ALTER SYSTEM SET work_mem = '#{results.values.max.to_sql}';
+          SELECT pg_reload_conf();
+          ```
+        MARKDOWN
+      end
+    end
+  end
+end

data/lib/tobias/evaluations.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Tobias
+  module Evaluations
+    def self.run(database, container, options)
+      results = []
+      results << WorkMem.new(database, container).run(options)
+      results
+    end
+  end
+end

data/lib/tobias/version.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
 module Tobias
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
+  SUMMARY = "Tobias is a tool to help you find the optimal work_mem for your queries."
+  DESCRIPTION = "Tobias is a tool to help you find the optimal work_mem for your queries."
 end

data/lib/tobias/work_mem.rb

@@ -2,10 +2,47 @@
 
 module Tobias
   class WorkMem
+    attr_reader :amount
+
+    def self.from_sql(sql)
+      case sql
+      when /^\d+B$/
+        new(sql.to_i)
+      when /^\d+kB$/
+        new(sql.to_i * 1024)
+      when /^\d+MB$/
+        new(sql.to_i * 1024 * 1024)
+      when /^\d+GB$/
+        new(sql.to_i * 1024 * 1024 * 1024)
+      else
+        raise "Invalid work_mem setting: #{sql}"
+      end
+    end
+
     def initialize(amount)
       @amount = amount
     end
 
+    def >(other)
+      @amount > other.amount
+    end
+
+    def <(other)
+      @amount < other.amount
+    end
+
+    def >=(other)
+      @amount >= other.amount
+    end
+
+    def <=(other)
+      @amount <= other.amount
+    end
+
+    def <=>(other)
+      @amount <=> other.amount
+    end
+
     def to_sql
       case @amount
       when 0...1024
@@ -30,6 +67,7 @@ module Tobias
       [
         new(64.kilobytes),
         new(128.kilobytes),
+        new(256.kilobytes),
         new(512.kilobytes),
         new(1.megabyte),
         new(4.megabytes),
@@ -44,7 +82,39 @@ module Tobias
         new(2.gigabytes),
         new(4.gigabytes),
         new(8.gigabytes),
-      ]
+      ].sort_by(&:amount)
+    end
+
+    # Inspects the database to determine the valid work_mem settings for the current user.
+    # We'll need at least connection_limit / effective_cache_size for an optimal
+    # work_mem setting, otherwise a user could run out of memory at max connections.
+    def self.valid_for(database)
+      role_conn_limit = database.select(:rolconnlimit).
+        from(:pg_roles).
+        where(rolname: Sequel.lit("current_user")).
+        first
+
+      max_connections = database.select(:setting).
+        from(:pg_settings).
+        where(name: "max_connections").
+        first
+
+      effective_cache_size = database.select(:setting, :unit).
+        from(:pg_settings).
+        where(name: "effective_cache_size").
+        first
+
+      effective_cache_size_bytes = effective_cache_size[:setting].to_i * 8 * 1024
+
+      connection_limit = if role_conn_limit[:rolconnlimit] > 0
+        role_conn_limit[:rolconnlimit]
+      else
+        max_connections[:setting].to_i
+      end
+
+      bytes_per_connection = effective_cache_size_bytes / connection_limit
+
+      self.all.select { |work_mem| work_mem.amount < bytes_per_connection.to_i }
     end
   end
-end
+end

data/lib/tobias.rb

@@ -19,11 +19,16 @@ require "active_support/all"
 require "sequel"
 require "enumerable-stats"
 require "benchmark"
+require "tty-markdown"
 
 $LOAD_PATH.unshift File.dirname(__FILE__)
 
+require "tobias/evaluations"
+require "tobias/evaluations/base"
+require "tobias/evaluations/work_mem"
+
 module Tobias
   autoload :CLI, "tobias/cli"
-  autoload :Evaluation, "tobias/evaluation"
+  autoload :Container, "tobias/container"
   autoload :WorkMem, "tobias/work_mem"
-end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: tobias
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Jon Daniel
 bindir: bin
 cert_chain: []
-date: 2025-08-03 00:00:00.000000000 Z
+date: 2025-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -210,20 +210,26 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 1.3.0
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: tty-markdown
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.12'
-  type: :development
+        version: '0.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.12'
-description: Tobias
+        version: '0.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+description: Tobias is a tool to help you find the optimal work_mem for your queries.
 email: binarycleric@gmail.com
 executables:
 - tobias
@@ -233,7 +239,10 @@ files:
 - bin/tobias
 - lib/tobias.rb
 - lib/tobias/cli.rb
-- lib/tobias/evaluation.rb
+- lib/tobias/container.rb
+- lib/tobias/evaluations.rb
+- lib/tobias/evaluations/base.rb
+- lib/tobias/evaluations/work_mem.rb
 - lib/tobias/version.rb
 - lib/tobias/work_mem.rb
 homepage: https://github.com/binarycleric/tobias
@@ -258,5 +267,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.2
 specification_version: 4
-summary: Tobias
+summary: Tobias is a tool to help you find the optimal work_mem for your queries.
 test_files: []

data/lib/tobias/evaluation.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Tobias
-  class Evaluation
-    def initialize(database)
-      @database = database
-    end
-  end
-end