rroonga 0.9.4-x86-mingw32 → 0.9.5-x86-mingw32

data/vendor/local/share/groonga/munin/plugins/groonga_cpu_load

@@ -0,0 +1,47 @@
+#!/bin/sh
+
+#%# family=auto
+#%# capabilities=autoconf
+
+case "$1" in
+    autoconf|detect)
+	if [ -z "${pid_file}" ]; then
+            echo "no (PID file isn't specified by env.pid_file)"
+	    exit 1
+        elif [ -f "${pid_file}" ]; then
+            echo "yes"
+	    exit 0
+        else
+            echo "no (PID file doesn't exist: ${pid_file})"
+	    exit 1
+        fi
+        ;;
+    config)
+	if [ -z "${label}" ]; then
+	    title="groonga: CPU load"
+	else
+	    title="groonga: ${label}: CPU load"
+	fi
+        cat <<EOF
+graph_title ${title}
+graph_vlabel CPU load (%)
+graph_category groonga
+graph_info groonga CPU load
+
+cpu_load.label CPU load
+cpu_load.type GAUGE
+EOF
+        exit 0
+        ;;
+    *)
+esac
+
+if [ -z "${pid_file}" ]; then
+    echo "PID file isn't specified by env.pid_file"
+    exit 1
+fi
+
+groonga_pid=$(cat ${pid_file})
+top_for_groonga=$(top -b -n 1 -p ${groonga_pid} | tail -2 | head -1)
+load_in_percent=$(echo ${top_for_groonga} | sed -r -e 's/ +/ /g' | cut -d' ' -f 9)
+echo "cpu_load.value ${load_in_percent}"

data/vendor/local/share/groonga/munin/plugins/groonga_cpu_time

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+#%# family=auto
+#%# capabilities=autoconf
+
+label = ENV["label"]
+pid_file = ENV["pid_file"]
+
+command = ARGV.shift
+
+case command
+when "autoconf", "detect"
+  if pid_file.nil?
+    puts "no (PID file isn't specified by env.pid_file)"
+    exit(false)
+  elsif File.exist?(pid_file)
+    puts "yes"
+    exit(true)
+  else
+    puts "no (PID file doesn't exist: #{pid_file})"
+    exit(false)
+  end
+when "config"
+  if label
+    title = "groonga: #{label}: CPU time"
+  else
+    title = "groonga: CPU time"
+  end
+  puts <<EOF
+graph_title #{title}
+graph_vlabel CPU time (days)
+graph_category groonga
+graph_info groonga CPU time
+
+cpu_time.label CPU time
+cpu_time.type GAUGE
+EOF
+  exit(true)
+end
+
+groonga_pid = File.read(pid_file).strip
+time = `ps h -o time -p #{groonga_pid}`.chomp
+if /\A(?:(\d+)-)?(\d+):(\d+):(\d+)\z/ =~ time
+  day, hours, minutes, seconds, = $1, $2, $3, $4
+  day = (day || 0).to_i
+  hours = hours.to_i
+  minutes = minutes.to_i
+  seconds = seconds.to_i
+  time_in_seconds = seconds + minutes * 60 + hours * 60 * 60
+  day_in_seconds = 60 * 60 * 24
+  fraction_in_day = time_in_seconds.to_f / day_in_seconds.to_f
+  cpu_time_in_day = day + fraction_in_day
+  puts "cpu_time.value #{cpu_time_in_day}"
+else
+  puts "invalid time format: <#{time}>"
+  exit(false)
+end

data/vendor/local/share/groonga/munin/plugins/groonga_disk

@@ -0,0 +1,162 @@
+#!/usr/bin/env ruby
+
+#%# family=auto
+#%# capabilities=autoconf
+
+require 'shellwords'
+require 'json'
+require 'English'
+
+label = ENV["label"]
+@groonga = ENV["groonga"] || "groonga"
+@du = ENV["du"] || "du"
+@path = ENV["path"]
+
+command = ARGV.shift
+
+def parse(success, result)
+  if success
+    begin
+      status, body = JSON.parse(result)
+      return_code, start_time, elapsed, error_message = status
+      if return_code.zero?
+        [success, body]
+      else
+        [false, error_message]
+      end
+    rescue JSON::ParserError
+      [false, $!.message]
+    end
+  else
+    [success, result]
+  end
+end
+
+def run(command, *args)
+  path = Shellwords.shellescape(@path)
+  result = `#{@groonga} #{path} #{command} #{args.join(' ')} 2>&1`
+  parse($?.success?, result)
+end
+
+def parse_list(header, list)
+  list.collect do |item|
+    parsed_item = {}
+    header.each_with_index do |(name, type), i|
+      parsed_item[name] = item[i]
+    end
+    parsed_item
+  end
+end
+
+def schema
+  tables = []
+  success, table_list_body = run("table_list")
+  unless success
+    puts "error: #{table_list_body}"
+    exit(false)
+  end
+  parse_list(table_list_body[0], table_list_body[1..-1]).each do |table|
+    table_name = table["name"]
+    table["key"] = "table_#{table_name}"
+    success, column_list_body = run("column_list", table_name)
+    unless success
+      puts "error: #{column_list_body}"
+      exit(false)
+    end
+    table["columns"] = parse_list(column_list_body[0], column_list_body[1..-1])
+    table["columns"].each do |column|
+      column["key"] = "column_#{table_name}_#{column['name']}"
+      column["full_name"] = "#{table_name}.#{column['name']}"
+    end
+    tables << table
+  end
+  tables
+end
+
+def parse_du_result(result)
+  usages = {}
+  result.each_line do |line|
+    if /\A(\d+)\s+/ =~ line
+      usage = $1
+      path = $POSTMATCH.strip
+      usages[path] = usage.to_i
+    end
+  end
+  usages
+end
+
+case command
+when "autoconf", "detect"
+  success, body = run("status")
+  if success
+    puts "yes"
+    exit(true)
+  else
+    puts "no (#{body})"
+    exit(false)
+  end
+when "config"
+  if label.nil?
+    title = "groonga: disk usage"
+  else
+    title = "groonga: #{label}: disk usage"
+  end
+  puts <<EOF
+graph_title #{title}
+graph_vlabel Bytes
+graph_category groonga
+graph_info disk usage in groonga tables and columns
+graph_args --base 1024
+graph_total Total
+
+database.label Database
+database.draw AREA
+EOF
+  schema.each do |table|
+    table_key = table["key"]
+    table_name = table["name"]
+    puts <<EOF
+
+#{table_key}.label #{table_name}
+#{table_key}.draw STACK
+EOF
+    table["columns"].each do |column|
+      column_key = column["key"]
+      column_name = column["full_name"]
+      puts <<EOF
+
+#{column_key}.label #{column_name}
+#{column_key}.draw STACK
+EOF
+    end
+  end
+  exit(true)
+end
+
+path = Shellwords.shellescape(@path)
+du_result = `#{@du} -B1 #{path}*`
+unless $?.success?
+  puts("error: #{du_result}")
+  exit(false)
+end
+usages = parse_du_result(du_result)
+usage = usages[@path] || 0
+puts <<EOF
+database.value #{usage}
+EOF
+schema.each do |table|
+  table_key = table["key"]
+  table_name = table["name"]
+  usage = usages[table["path"]] || 0
+  puts <<EOF
+#{table_key}.value #{usage}
+EOF
+  table["columns"].each do |column|
+    column_key = column["key"]
+    usage = usages[column["path"]] || 0
+    usage += usages["#{column['path']}.c"] || 0
+    puts <<EOF
+#{column_key}.value #{usage}
+EOF
+  end
+end

data/vendor/local/share/groonga/munin/plugins/groonga_memory

@@ -0,0 +1,51 @@
+#!/bin/sh
+
+#%# family=auto
+#%# capabilities=autoconf
+
+case "$1" in
+    autoconf|detect)
+	if [ -z "${pid_file}" ]; then
+            echo "no (PID file isn't specified by env.pid_file)"
+	    exit 1
+        elif [ -f "${pid_file}" ]; then
+            echo "yes"
+            exit 0
+        else
+            echo "no (PID file doesn't exist: ${pid_file})"
+            exit 1
+        fi
+        ;;
+    config)
+	if [ -z "${label}" ]; then
+	    title="groonga: memory usage"
+	else
+	    title="groonga: ${label}: memory usage"
+	fi
+        cat <<EOF
+graph_title ${title}
+graph_vlabel memory usage
+graph_category groonga
+graph_info groonga memory usage
+
+rss.label resident set size
+rss.type GAUGE
+vsz.label virtual memory size
+vsz.type GAUGE
+EOF
+        exit 0
+        ;;
+    *)
+esac
+
+if [ -z "${pid_file}" ]; then
+    echo "PID file isn't specified by env.pid_file"
+    exit 1
+fi
+
+groonga_pid=$(cat ${pid_file})
+read rss_in_kb vsz_in_kb <<EOC
+$(ps h -o rss,vsz -p ${groonga_pid})
+EOC
+echo "rss.value ${rss_in_kb}000"
+echo "vsz.value ${vsz_in_kb}000"

data/vendor/local/share/groonga/munin/plugins/groonga_n_records

@@ -0,0 +1,110 @@
+#!/usr/bin/env ruby
+
+#%# family=auto
+#%# capabilities=autoconf
+
+require 'shellwords'
+require 'json'
+
+label = ENV["label"]
+@groonga = ENV["groonga"] || "groonga"
+@host = ENV["host"] || "localhost"
+@port = ENV["port"] || 10041
+@path = ENV["path"]
+
+command = ARGV.shift
+
+def parse(success, result)
+  if success
+    begin
+      status, body = JSON.parse(result)
+      return_code, start_time, elapsed, error_message = status
+      if return_code.zero?
+        [success, body]
+      else
+        [false, error_message]
+      end
+    rescue JSON::ParserError
+      [false, $!.message]
+    end
+  else
+    [success, result]
+  end
+end
+
+def run(command, *args)
+  if @path
+    path = Shellwords.shellescape(@path)
+    result = `#{@groonga} #{path} #{command} #{args.join(' ')} 2>&1`
+  else
+    groonga = "#{@groonga} -p #{@port} -c #{@host}"
+    result = `#{groonga} #{command} #{args.join(' ')} 2>&1`
+  end
+  parse($?.success?, result)
+end
+
+def parse_list(header, list)
+  list.collect do |item|
+    parsed_item = {}
+    header.each_with_index do |(name, type), i|
+      parsed_item[name] = item[i]
+    end
+    parsed_item
+  end
+end
+
+case command
+when "autoconf", "detect"
+  success, body = run("status")
+  if success
+    puts "yes"
+    exit(true)
+  else
+    puts "no (#{body})"
+    exit(false)
+  end
+when "config"
+  if label.nil?
+    title = "groonga: number of records"
+  else
+    title = "groonga: #{label}: number of records"
+  end
+  puts <<EOF
+graph_title #{title}
+graph_vlabel records
+graph_category groonga
+graph_info number of records in groonga table
+EOF
+  success, body = run("table_list")
+  unless success
+    puts "error: #{body}"
+    exit(false)
+  end
+  parse_list(body[0], body[1..-1]).each do |table|
+    name = table["name"]
+    puts <<EOF
+
+#{name}.label #{name}
+#{name}.type GAUGE
+EOF
+  end
+  exit(true)
+end
+
+success, body = run("table_list")
+unless success
+  puts("error: #{body}")
+  exit(false)
+end
+parse_list(body[0], body[1..-1]).each do |table|
+  name = table["name"]
+  success, body = run("select", "#{name} --limit 0")
+  unless success
+    puts("error: #{body}")
+    exit(false)
+  end
+  n_records = body[0][0][0]
+  puts <<EOF
+#{name}.value #{n_records}
+EOF
+end

data/vendor/local/share/groonga/munin/plugins/groonga_query_performance

@@ -0,0 +1,133 @@
+#!/usr/bin/env ruby
+
+#%# family=auto
+#%# capabilities=autoconf
+
+require 'English'
+require 'strscan'
+
+label = ENV["label"]
+
+@log_path = ENV["log_path"]
+
+command = ARGV.shift
+
+case command
+when "autoconf", "detect"
+  if @log_path.nil?
+    puts "no (query log file path isn't specified by env.log_path)"
+    exit(false)
+  end
+  unless File.readable?(@log_path)
+    puts "no (query log file isn't readable: <#{@log_path}>)"
+    exit(false)
+  end
+  puts "yes"
+  exit(true)
+when "config"
+  if label.nil?
+    title = "groonga: query performance"
+  else
+    title = "groonga: #{label}: query performance"
+  end
+  puts <<EOF
+graph_title #{title}
+graph_vlabel seconds
+graph_category groonga
+graph_info groonga query performance
+
+longest.label Longest
+average.label Average
+median.label Median
+EOF
+  exit(true)
+end
+
+class ReverseLineReader
+  def initialize(io)
+    @io = io
+    @io.seek(0, IO::SEEK_END)
+    @buffer = ""
+    @data = ""
+  end
+
+  def each
+    separator = $/
+    separator_length = separator.length
+    while read_to_buffer
+      loop do
+        index = @buffer.rindex(separator, @buffer.length - 1 - separator_length)
+        break if index.nil? or index.zero?
+        last_line = @buffer.slice!((index + separator_length)..-1)
+        yield(last_line)
+      end
+    end
+    yield(@buffer) unless @buffer.empty?
+  end
+
+  private
+  BYTES_PER_READ = 4096
+  def read
+    position = @io.pos
+    if position < BYTES_PER_READ
+      bytes_per_read = position
+    else
+      bytes_per_read = BYTES_PER_READ
+    end
+
+    if bytes_per_read.zero?
+      @data.replace("")
+    else
+      @io.seek(-bytes_per_read, IO::SEEK_CUR)
+      @io.read(bytes_per_read, @data)
+      @io.seek(-bytes_per_read, IO::SEEK_CUR)
+    end
+
+    @data
+  end
+
+  def read_to_buffer
+    data = read
+    if data.empty?
+      false
+    else
+      @buffer.insert(0, data)
+      true
+    end
+  end
+end
+
+span = 60 * 5 # 5min
+mega = 1_000_000.0
+now = Time.now
+elapsed_times = []
+File.open(@log_path) do |log_file|
+  ReverseLineReader.new(log_file).each do |line|
+    case line
+    when /\A(\d+)-(\d+)-(\d+) (\d+):(\d+):(\d+)\.(\d+)\|([\da-f])+\|<(\d+) rc=0$/
+      _, year, month, day, hour, minutes, seconds, milliseconds,
+        context, elapsed = $LAST_MATCH_INFO.to_a
+      time_stamp = Time.local(year, month, day,
+                              hour, minutes, seconds, milliseconds)
+      difference = now - time_stamp
+      break if difference > span
+      elapsed_in_micro_seconds = elapsed.to_i / mega
+      elapsed_times << elapsed_in_micro_seconds
+    end
+  end
+end
+
+sorted_elapsed_times = elapsed_times.sort
+if sorted_elapsed_times.empty?
+  longest = 0
+  average = 0
+  median = 0
+else
+  longest = sorted_elapsed_times.last
+  average = sorted_elapsed_times.inject(&:+) / sorted_elapsed_times.size.to_f
+  median = sorted_elapsed_times[sorted_elapsed_times.size / 2]
+end
+
+puts "longest.value #{longest}"
+puts "average.value #{average}"
+puts "median.value #{median}"