elefant 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 088dc5c6b9b4cbaa02e1497445dc9fb3cb5d1f83
+  data.tar.gz: f7cf82d109b27295d28a8ed2c9726fa5c7eb0965
+SHA512:
+  metadata.gz: 7f57ab871b8301a5671b8bbdaa914b5d90502ec160ab48694d6c0e7b904322db390ae9302453284cc02f1315dae0d02e9c893c7d029619084c522f8348e92a36
+  data.tar.gz: e84818a8ba32bb9bf34c1fba56d26eb7e16d4b79ae85d1e7d983c8fcc612acd070b2694c063ee7205db5f2baa219fddb222b717a7e380bf99e2063994b5e851f

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+test/config.yml
+.sass-cache
+**/.DS_Store
+

data/.ruby-gemset

@@ -0,0 +1 @@
+elefant-gem

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0-p645

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+rvm:
+  - 2.2.0
+  - 2.1.5
+  - 2.0.0
+  - 1.9.3
+
+addons:
+  postgresql: "9.3"
+
+before_script:
+  - psql -c 'create database elefant_test;' -U postgres
+  - cp test/config.yml.example test/config.yml

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in elefant.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Christoph Sassenberg
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,65 @@
+# Elefant
+
+[![Build Status](https://travis-ci.org/defsprite/elefant.svg?branch=master)](https://travis-ci.org/defsprite/elefant)
+
+When you are running a small / medium sized project, there is usually not a dedicated DBA and you rarely care about the database analytics that PostgreSQL gives you for free.
+Elefant tries to help a little with that by providing web interface for some basic database analytics as a small mountable rack application.
+
+![Screenshot](https://raw.githubusercontent.com/defsprite/elefant/master/web/public/img/screenshot.png)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'elefant'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install elefant
+
+## Usage
+
+### Standalone
+
+Run the web interface as a standalone rack application:
+
+    $ DATABASE_URL=postgres:///some_db_connection_string elefant-web
+    
+or if you want to use a different database specifically for elefant:
+
+    $ ELEFANT_DATABASE_URL=postgres:///some_db_connection_string elefant-web
+
+### Rails
+    
+You can mount the web interface in a rails application by adding this to `config/routes.rb`:
+
+```ruby
+require 'elefant/web'
+mount Elefant::Web => '/elefant'
+```
+It will pick up a connection from the `ActiveRecord` connection pool.
+
+:warning: There is no authentication built in! Mounting it as described above is probably a bad idea! :warning:
+
+In case you are using [Devise](https://github.com/plataformatec/devise), here is an example of mounting only for 
+authenticated users of the `:admin` scope:
+
+```ruby
+authenticate(:admin) do
+  require 'elefant/web'
+  mount Elefant::Web => '/elefant'
+end 
+```
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require "rake/testtask"
+
+Rake::TestTask.new do |task|
+  task.libs << %w(test lib)
+  task.pattern = "test/*_test.rb"
+end
+
+task :default => :test

data/bin/elefant-web

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+app = File.expand_path('../../config.ru', __FILE__)
+system("bundle exec rackup '#{app}'")

data/config.ru

@@ -0,0 +1,4 @@
+require 'elefant'
+require 'elefant/web'
+
+run Elefant::Web

data/elefant.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'elefant/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "elefant"
+  gem.version       = Elefant::VERSION
+  gem.authors       = ["Christoph Sassenberg"]
+  gem.email         = ["christoph.sassenberg@googlemail.com"]
+  gem.description   = %q{The elefant gem gives you a few insights analytics about your PostgreSQL database}
+  gem.summary       = %q{Know your PostgreSQL database}
+  gem.homepage      = "http://github.com/defsprite/elefant"
+  gem.licenses      = ["MIT"]
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'pg', '~> 0.15'
+  gem.add_dependency 'sinatra', '~> 1.4'
+  gem.add_dependency 'sinatra-partial', '~> 0.4'
+  gem.add_dependency 'i18n', '~> 0.7'
+
+  gem.add_development_dependency 'rake', '~> 10.4'
+  gem.add_development_dependency 'minitest', '~> 5.5'
+  gem.add_development_dependency 'rack-test', '~> 0.6'
+  gem.add_development_dependency 'watchr', '~> 0.7'
+  gem.add_development_dependency 'activerecord', '~> 4.2'
+  gem.add_development_dependency 'sass', '~> 3.4'
+end

data/lib/elefant.rb

@@ -0,0 +1,22 @@
+require "elefant/version"
+require "elefant/stats"
+
+module Elefant
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    configuration = self.configuration
+    yield(configuration)
+  end
+
+  class Configuration
+    attr_accessor :disable_ar
+
+    def initialize
+      @disable_ar = false
+    end
+  end
+end

data/lib/elefant/connection_adapter.rb

@@ -0,0 +1,122 @@
+require "uri"
+require "pg"
+
+module Elefant
+  class ConnectionAdapter
+
+    attr_accessor :connection
+
+    def initialize(connection=nil)
+      @connection = connection.nil? ? establish_new : validate!(connection)
+    end
+
+    def execute(stmt, params = [])
+      begin
+        params = nil if params.empty?
+        r = @connection.exec(stmt, params)
+        result = []
+        r.each do |t|
+          result << t
+        end
+        result
+      rescue PGError => e
+        @connection.reset
+        raise e
+      end
+    end
+
+    def disconnect
+      begin
+        if active_record?
+          @connection = nil
+          ActiveRecord::Base.clear_active_connections!
+        else
+          @connection.close
+        end
+      rescue => e
+        # TODO: log something and do sensible stuff
+        raise e
+      end
+    end
+
+    def alive?
+      @connection.query "SELECT 1"
+      true
+    rescue PGError
+      false
+    end
+
+    def info
+      @info ||= {
+          db_name: @connection.db,
+          server_version: version_str(connection.server_version),
+          client_version: (PG.respond_to?( :library_version ) ? version_str(PG.library_version) : 'unknown')
+      }
+    end
+
+    def db_name
+      @connection.db
+    end
+
+    def active_record?
+      defined?(ActiveRecord::Base) == "constant" && ActiveRecord::Base.class == Class && !Elefant.configuration.disable_ar
+    end
+
+    private
+
+    def version_str(number)
+      number.to_s.tr('0','.').gsub(/(\.)+\z/, '')
+    end
+
+    def validate!(c)
+      return c if c.is_a?(PG::Connection)
+      err = "connection must be an instance of PG::Connection, but was #{c.class}"
+      raise(ArgumentError, err)
+    end
+
+    def establish_new
+      #QC.log(:at => "establish_conn")
+      connection = if active_record?
+                     establish_ar
+                   else
+                     establish_pg
+                   end
+      connection.exec("SET application_name = 'Elefant Stats #{Elefant::VERSION}'")
+      connection
+    end
+
+    def establish_pg
+      PGconn.connect(*normalize_db_url(db_url))
+      # if conn.status != PGconn::CONNECTION_OK
+      #   log(:error => conn.error)
+      # end
+    end
+
+    def establish_ar
+      ActiveRecord::Base.connection.raw_connection
+    end
+
+    def normalize_db_url(url)
+      host = url.host
+      host = host.gsub(/%2F/i, '/') if host
+
+      [
+          host, # host or percent-encoded socket path
+          url.port || 5432,
+          nil, "", #opts, tty
+          url.path.gsub('/', ''), # database name
+          url.user,
+          url.password
+      ]
+    end
+
+    def db_url
+      return @db_url if defined?(@db_url) && @db_url
+
+      url = ENV["ELEFANT_DATABASE_URL"] ||
+          ENV["DATABASE_URL"] ||
+          raise(ArgumentError, "missing ELEFANT_DATABASE_URL or DATABASE_URL")
+      @db_url = URI.parse(url)
+    end
+  end
+end

data/lib/elefant/postgres/size_queries.rb

@@ -0,0 +1,31 @@
+module Elefant
+  module Postgres
+    module SizeQueries
+
+      def top_sizes(limit = 20)
+        exec %Q{
+          SELECT
+            relname AS name,
+            relkind AS kind,
+            pg_size_pretty(pg_relation_size(pg_class.oid)) AS size
+          FROM
+            pg_class
+          ORDER BY
+            pg_relation_size(pg_class.oid) DESC
+          LIMIT #{limit}
+        }
+      end
+
+      def size
+        exec %Q{
+          SELECT
+            '#{@connection.db_name}' AS db_name,
+            count(oid) AS num_rels,
+            pg_size_pretty(pg_database_size('#{@connection.db_name}')) AS dbsize
+          FROM
+            pg_class
+        }
+      end
+    end
+  end
+end

data/lib/elefant/postgres/stat_queries.rb

@@ -0,0 +1,91 @@
+module Elefant::Postgres
+  module StatQueries
+
+    def initialize(connection)
+      @connection = connection
+    end
+
+    def activity
+      exec %Q{
+          SELECT
+            -- datid
+            -- datname
+            -- pid
+            -- usesysid
+            usename          AS act_user,
+            application_name AS act_app,
+            client_addr      AS act_c_addr,
+            client_hostname  AS act_c_host,
+            client_port      AS act_c_port,
+            backend_start    AS act_bknd_start,
+            xact_start       AS act_tx_start,
+            query_start      AS act_q_start,
+            state_change     AS act_st_chng,
+            waiting          AS act_wtng,
+            state            AS act_state,
+            query            AS act_qry
+          FROM
+            pg_stat_activity
+          WHERE
+            datname = '%s';
+      } % [@connection.db_name]
+    end
+
+    def user_tables
+      exec %Q{
+        SELECT
+          relname        AS rel_name,
+          heap_blks_read AS heap_blks_rd,
+          heap_blks_hit  AS heap_blks_ht,
+          idx_blks_read  AS idx_blks_rd,
+          idx_blks_hit   AS idx_blks_ht
+        FROM
+          pg_statio_user_tables;
+      }
+    end
+
+    def user_indexes
+      exec %Q{
+        SELECT
+          -- relid
+          -- indexrelid
+          -- schemaname
+          relname AS rel_name,
+          indexrelname AS idx_name,
+          idx_scan AS idx_scn,
+          idx_tup_read AS idx_tup_rd,
+          idx_tup_fetch  AS idx_tup_ftch
+        FROM
+          pg_stat_user_indexes;
+      }
+    end
+
+    def summary
+      exec %Q{
+        SELECT
+          now()                          AS db_time,
+          MAX(stat_db.xact_commit)       AS commits,
+          MAX(stat_db.xact_rollback)     AS rollbks,
+          MAX(stat_db.blks_read)         AS blksrd,
+          MAX(stat_db.blks_hit)          AS blkshit,
+          MAX(stat_db.numbackends)       AS bkends,
+          SUM(stat_tables.seq_scan)      AS seqscan,
+          SUM(stat_tables.seq_tup_read)  AS seqtprd,
+          SUM(stat_tables.idx_scan)      AS idxscn,
+          SUM(stat_tables.idx_tup_fetch) AS idxtrd,
+          SUM(stat_tables.n_tup_ins)     AS ins,
+          SUM(stat_tables.n_tup_upd)     AS upd,
+          SUM(stat_tables.n_tup_del)     AS del,
+          MAX(stat_locks.locks)          AS locks,
+          MAX(activity.sess)             AS activeq
+        FROM
+          pg_stat_database    AS stat_db,
+          pg_stat_user_tables AS stat_tables,
+          (SELECT COUNT(*) AS locks FROM pg_locks ) AS stat_locks,
+          (SELECT COUNT(*) AS sess FROM pg_stat_activity WHERE query <> '<IDLE>') AS activity
+        WHERE
+          stat_db.datname = '%s';
+		  } % [@connection.db_name]
+    end
+  end
+end