whatbug 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1e95630e8ed7dd2bf91f11e7373386edfc20b1b5
+  data.tar.gz: 4b8d89d58408c3503ae76d68d89257cc1b35c4f6
+SHA512:
+  metadata.gz: e141682dcd4d9511cbb4927a1777a486c00f5800914fbf911c4e95846b604651accc66c437c280b221d385357a8ad3a90c6ce8008192fd374e7e17d7eee5fc71
+  data.tar.gz: c1a58b2dafa4085a244bb1dc4a556e5d6ed59ff628cf18c750863be97906ade0d2bde0af0dc5a46b07165cfe4ac287b203d97d67c6592d06c8d8e96bef467eba

data/bin/whatbug

@@ -0,0 +1,132 @@
+#! /usr/bin/env ruby
+
+require "dotenv"
+
+require_relative "../lib/git_client"
+require_relative "../lib/rollbar_client"
+require_relative "../lib/airbrake_client"
+require_relative "../lib/tracer"
+
+Dotenv.load()
+
+BLAME_DATE_RGX = /\([^)]*\)/
+DATE_RGX = /\d{1,4}[-.\/]\d{1,2}[-.\/]\d{1,4}/
+
+def get_error(id)
+  raise "No error ID given" if id.nil? || id.length == 0
+
+  if ENV.has_key?("ROLLBAR_API_KEY")
+    config = {
+      "username" => ENV["ROLLBAR_USERNAME"],
+      "api_key" => ENV["ROLLBAR_API_KEY"],
+      "project" => ENV["ROLLBAR_PROJECT"],
+      "environment" => ENV["ROLLBAR_ENVIRONMENT"]
+    }
+    errorClass = RollbarClient
+  elsif ENV.has_key?("AIRBRAKE_API_KEY")
+    config = {
+      "api_key" => ENV["AIRBRAKE_API_KEY"],
+      "project_id" => ENV["AIRBRAKE_PROJECT_ID"],
+      "environment" => ENV["AIRBRAKE_ENVIRONMENT"]
+    }
+    errorClass = AirbrakeClient
+  else
+    raise "Unable to find ENV VARS for AIRBRAKE_API_KEY or ROLLBAR_API_KEY"
+  end
+
+  errorClass
+    .new(config)
+    .get_error(id)
+end
+
+def map_code(file, func, line, cutoff)
+  blames = GitClient
+    .new
+    .blame(file[:path], func[:start], func[:end])
+    .map do |blame_line|
+      date = blame_line
+        .scan(BLAME_DATE_RGX)
+        .first
+        .gsub(/\s+\d+\)$/, "")
+
+      commit = blame_line.split(" ").first
+      date_start = date.index(DATE_RGX)
+      author = date[1...(date_start - 1)]
+      date = DateTime.parse(date[date_start..-1]) rescue DateTime.new
+
+      {
+        commit: commit,
+        author: author,
+        date: date
+      }
+    end
+
+  start = func[:start] - 1
+  file[:code][start...func[:end]]
+    .each_with_index
+    .map do |line, index|
+      blame = blames.shift()
+      {
+        text: line,
+        line_num: func[:start] + index,
+        changed: blame[:date] > cutoff,
+        in_trace: false,
+        blame: blame
+      }
+    end
+end
+
+def main(error_id, cutoff)
+  cutoff = cutoff.nil? ? (Date.today - 7).to_datetime : DateTime.parse(cutoff)
+  tracer = Tracer.new()
+
+  error = get_error(error_id)
+  files = error[:stack_trace]
+    .map { |trace| trace[:file] }
+    .uniq
+    .reduce({}) do |acc, file|
+      parts = File.split(ENV["PROJECT_ROOT"]) + file.split("/")
+      path = File.join(*parts)
+      code = File.read(path)
+      acc[file] = {
+        path: file,
+        code: code.lines,
+        funcs: tracer.trace(path, code)
+      }
+      acc
+    end
+
+  Dir.chdir(ENV["PROJECT_ROOT"])
+  traced_functions = error[:stack_trace]
+    .reduce({})  do |acc, trace|
+      file = files[trace[:file]]
+      line = trace[:line]
+      func = file[:funcs].detect { |func| func[:start] <= line && func[:end] >= line }
+      if not func.nil?
+        line_start = line - func[:start]
+
+        acc[trace[:file]] ||= {}
+        acc[trace[:file]][func[:name]] ||= map_code(file, func, line, cutoff)
+        acc[trace[:file]][func[:name]][line_start][:in_trace] = true
+      end
+      acc
+    end
+
+  traced_functions
+    .each do |file_name, funcs|
+      funcs.each do |func_name, func|
+        trace_line = func.detect { |l| l[:in_trace] }
+
+        puts "#{file_name}:#{trace_line[:line_num]} - #{func_name}"
+        func.each do |line|
+          line_num = line[:line_num].to_s.rjust(3, " ")
+          change_sym = line[:changed] ? "+" : " "
+          trace_sym = line[:in_trace] ? "X" : " "
+
+          puts "#{change_sym}#{trace_sym}#{line_num}) #{line[:text]}"
+        end
+      end
+    end
+end
+
+main(ARGV[0], ARGV[1])

data/lib/airbrake_client.rb

@@ -0,0 +1,67 @@
+require "json"
+require "date"
+require "net/http"
+require "active_support/core_ext/hash"
+
+class AirbrakeClient
+  PROJECT_ROOT_RGX = /^\[PROJECT_ROOT\]/
+
+  def initialize(config)
+    @key = config["api_key"]
+    @project_id = config["project_id"]
+    @environment = config["environment"]
+    @errors = @key.nil? ? [] : errors()
+    @deploys = @key.nil? ? [] : deploys()
+  end
+
+  def get_error(group_id)
+    parse_trace(select_traces({"id" => group_id}).first)
+  end
+
+  private
+
+  def parse_trace(trace)
+    stack_trace = (trace["backtrace"] || [])
+      .reject { |trace| trace["file"].nil? }
+      .map do |trace|
+        file = trace["file"].gsub(PROJECT_ROOT_RGX, "")
+        line = trace["line"]
+        function = trace["function"]
+
+        {
+          file: file,
+          line: line,
+          function: function
+        }
+      end
+
+    {
+      error_id: trace["id"].to_sym,
+      first_time: DateTime.rfc3339(trace["createdAt"]),
+      last_time: DateTime.rfc3339(trace["lastNoticeAt"]),
+      link: "https://airbrake.io/projects/#{@project_id}/groups/#{trace["id"]}",
+      environment: trace["context"]["environment"],
+      type: trace["type"],
+      message: trace["message"],
+      total_occurrences: trace["noticeTotalCount"],
+      stack_trace: stack_trace
+    }
+  end
+
+  def select_traces(group)
+    notices = fetch_error(group["id"])["notices"]
+    error = notices.first["errors"].first
+    group["backtrace"] = error["backtrace"]
+    group["type"] = error["type"]
+    group["message"] = error["message"]
+    [group]
+  rescue
+    []
+  end
+
+  def fetch_error(group_id)
+    JSON.parse(Net::HTTP.get(
+      URI("https://airbrake.io/api/v4/projects/#{@project_id}/groups/#{group_id}/notices?key=#{@key}")
+    ))
+  end
+end

data/lib/c_syntax_tracer.rb

@@ -0,0 +1,111 @@
+class CSyntaxTracer
+  def trace(code)
+    code = strip_comments(code)
+    find_funcs(code)
+      .map { |func| define_func(func, code) }
+  rescue
+    []
+  end
+
+  private
+
+  def find_funcs(code)
+    funcs = code.scan(/[a-zA-Z \t]*function\s+[A-Za-z_][A-Za-z0-9_]*/)
+    funcs += code.scan(/[a-zA-Z0-9_. \t]*\s*=\s*function/)
+
+    funcs = funcs
+      .each_with_index
+      .map do |func, index|
+        if func.match(/[a-zA-Z0-9_]*\s+=/)
+          name = func
+            .split("=")
+            .last(2)
+            .first
+            .split(/[ \t.]/)
+            .last
+        else
+          name = func.split(" ").last
+        end
+
+        [name] + code
+          .lines
+          .each_with_index
+          .select { |line, line_num| line.match(func) }
+          .first
+      end
+
+    funcs
+      .each_with_index
+      .map do |func, index|
+        if funcs.count > index + 2
+          func << funcs[index + 1].last
+        else
+          func << code.lines.count
+        end
+        func
+      end
+  end
+
+  def define_func(func, code)
+    function_code = code.lines[func[2]...func[3]]
+    indent = function_code
+      .first
+      .match(/^\s*/)[0]
+
+    close = function_code
+      .each_with_index
+      .select { |line, line_num| line.match(Regexp.compile("^#{indent}}")) }
+      .first
+
+    close ||= function_code
+      .each_with_index
+      .map { |line, line_num| [line.match(/}/), line_num] }
+      .select { |line| line.first }
+      .reverse
+      .first
+
+    end_line = close.nil? ? func[3] : func[2] + close.last + 1
+
+    {
+      name: func.first,
+      start: func[2] + 1,
+      end: end_line
+    }
+  end
+
+  def strip_comments(code)
+    block_captures.each do |block_capture|
+      matches = code.scan(block_capture[:regex])
+      matches.each do |match|
+        code = code.gsub(match, "#{block_capture[:start]} #{block_capture[:type]}" + "\n" * (match.lines.count - 1) + block_capture[:end])
+      end
+    end
+
+    line_captures.each do |line_capture|
+      code = code.gsub(line_capture[:regex], "#{line_capture[:start]} #{line_capture[:type]}")
+    end
+
+    code
+  end
+
+  def line_captures()
+    [
+      {
+        regex: /\/\/.*/,
+        type: "LINE COMMENT",
+        start: "//"
+      }
+    ]
+  end
+
+  def block_captures()
+    [
+      {
+        regex: /\/\*.*?\*\//m,
+        type: "BLOCK QUOTE",
+        start: "/*",
+        end: "*/"
+      }
+    ]
+  end
+end

data/lib/git_client.rb

@@ -0,0 +1,14 @@
+class GitClient
+  def blame(file, line_start, line_end)
+    exec("blame #{file} -L #{line_start},#{line_end}")
+  end
+
+  private
+
+  def exec(cmd)
+    `git --git-dir=#{@git_dir || ".git"} #{cmd}`
+      .encode("UTF-8", {invalid: :replace})
+      .lines
+      .map(&:chomp)
+  end
+end

data/lib/python_tracer.rb

@@ -0,0 +1,103 @@
+require "byebug"
+
+class PythonTracer
+  def trace(code)
+    code = strip_comments(code)
+    find_funcs(code)
+      .map { |func| define_func(func, code) }
+  rescue => e
+    byebug
+    []
+  end
+
+  private
+
+  def find_funcs(code)
+    funcs = code.scan(/[ \t]*def\s+[A-Za-z_][A-Za-z0-9_]*.*?\)\:/m)
+
+    funcs = funcs
+      .each_with_index
+      .map do |func, index|
+        name = func.split("(").first.split(" ").last
+
+        [name, func.lines.count] + code
+          .lines
+          .each_with_index
+          .select { |line, line_num| line.match(func.split("(").first) }
+          .first
+      end
+
+    funcs
+      .each_with_index
+      .map do |func, index|
+        if funcs.count > index + 2
+          func << funcs[index + 1].last
+        else
+          func << code.lines.count
+        end
+        func
+      end
+  end
+
+  def define_func(func, code)
+    function_code = code.lines[func[3]...func[4]]
+    indent = function_code
+      .first[/^\s*/]
+      .size
+
+    close = function_code[func[1]..-1]
+      .each_with_index
+      .select do |line, line_num|
+        line_indent = line[/^\s*/].size
+        line.match(/[^\s]/) && line_indent <= indent
+      end
+      .first
+
+    end_line = close.nil? ? func[4] : func[3] + close.last + func[1]
+    while code.lines[end_line - 1].match(/^\s+$/) do
+      end_line -= 1
+    end
+
+    {
+      name: func.first,
+      start: func[3] + 1,
+      end: end_line
+    }
+  end
+
+  def strip_comments(code)
+    block_captures.each do |block_capture|
+      matches = code.scan(block_capture[:regex])
+      matches.each do |match|
+        code = code.gsub(match, "#{block_capture[:start]} #{block_capture[:type]}" + "\n" * (match.lines.count - 1) + block_capture[:end])
+      end
+    end
+
+    line_captures.each do |line_capture|
+      code = code.gsub(line_capture[:regex], "#{line_capture[:start]} #{line_capture[:type]}")
+    end
+
+    code.tr("\t", " ")
+  end
+
+  def line_captures()
+    [
+      {
+        regex: /#.*/,
+        type: "LINE COMMENT",
+        start: "#"
+      }
+    ]
+  end
+
+  def block_captures()
+    [
+      {
+        regex: /\/\'''.*?\'''\//m,
+        type: "BLOCK QUOTE",
+        start: "'''",
+        end: "'''"
+      }
+    ]
+  end
+end

data/lib/rollbar_client.rb

@@ -0,0 +1,87 @@
+require "json"
+require "date"
+require "net/http"
+
+class RollbarClient
+  PROJECT_ROOT_RGX = /^\/app\//
+
+  def initialize(config)
+    @user = config["username"]
+    @key = config["api_key"]
+    @project = config["project"]
+    @environment = config["environment"]
+  end
+
+  def get_error(error_id)
+    item = fetch_item_by_counter_id(error_id)
+    parse_trace(select_traces(item["result"]).first)
+  end
+
+  private
+
+  def fetch_item_by_counter_id(item_id)
+    item = JSON.parse(Net::HTTP.get(
+      URI("https://api.rollbar.com/api/1/item_by_counter/#{item_id}/?access_token=#{@key}")
+    ))
+    uri = item["result"]["uri"]
+    JSON.parse(Net::HTTP.get(
+      URI("https://api.rollbar.com#{uri}")
+    ))
+  rescue
+    raise "Error #{error_id} not found"
+  end
+
+  def parse_trace(trace)
+    stack_trace = trace["frames"].map do |frame|
+      file = frame["filename"].gsub(PROJECT_ROOT_RGX, "")
+      line = frame["lineno"]
+      function = frame["method"]
+
+      {
+        file: file,
+        line: line,
+        function: function
+      }
+    end
+
+    {
+      error_id: trace[:id],
+      first_time: trace[:first_time],
+      last_time: trace[:last_time],
+      environment: trace[:environment],
+      type: trace[:type],
+      message: trace[:message],
+      link: "https://rollbar.com/#{@user}/#{@project}/items/#{trace[:counter]}/",
+      total_occurrences: trace[:total_occurrences],
+      stack_trace: stack_trace.reverse()
+    }
+  end
+
+  def select_traces(item)
+    error = detail_error(item["id"])["result"]["instances"].first
+    traces = error["data"]["body"]["trace"].present? ?
+      [error["data"]["body"]["trace"]] :
+      error["data"]["body"]["trace_chain"]
+
+    return nil if traces.nil?
+
+    traces.map do |trace|
+      trace[:id] = item["id"].to_s.to_sym
+      trace[:environment] = item["environment"]
+      trace[:total_occurrences] = item["total_occurrences"]
+      trace[:error] = error
+      trace[:type] = item["level"]
+      trace[:message] = item["title"]
+      trace[:first_time] = Time.at(item["first_occurrence_timestamp"]).to_datetime
+      trace[:last_time] = Time.at(item["last_occurrence_timestamp"]).to_datetime
+      trace[:counter] = item["counter"]
+      trace
+    end
+  end
+
+  def detail_error(item_id)
+    JSON.parse(Net::HTTP.get(
+      URI("https://api.rollbar.com/api/1/item/#{item_id}/instances/?access_token=#{@key}")
+    ))
+  end
+end

data/lib/ruby_tracer.rb

@@ -0,0 +1,64 @@
+require "ripper"
+
+class RubyTracer
+  # TODO: Handle other languages...
+  def trace(file)
+    out = Ripper.sexp(file)
+
+    funcs = find_funcs(out.last)
+      .map { |func| define_func(func, file.lines) }
+  rescue
+    []
+  end
+
+  private
+
+  def find_funcs(ast)
+    ast.reduce([]) do |acc, ast|
+      if ast.is_a?(Array)
+        if ast.first == :def
+          acc << ast
+        else
+          ast
+            .select { |tree| tree.is_a?(Array) }
+            .each do |sub_ast|
+              acc << sub_ast if sub_ast.first == :def
+              acc.concat(find_funcs(sub_ast)) if sub_ast.is_a?(Array)
+            end
+        end
+      end
+      acc
+    end
+  end
+
+  def trace_func(ast)
+    ast
+      .reduce([]) do |acc, ast|
+        if ast.is_a?(Array)
+          lines = ast.last
+          if lines.is_a?(Array) && lines.count == 2 && lines.first.is_a?(Integer) && lines.last.is_a?(Integer)
+            acc << lines.first
+          else
+            acc.concat(trace_func(ast))
+          end
+        end
+        acc
+      end
+      .uniq()
+  end
+
+  def define_func(ast, file_lines)
+    name = ast[1][1]
+    lines = trace_func(ast)
+
+    if file_lines[lines.last].strip() == "end"
+      lines << lines.last + 1
+    end
+
+    {
+      name: name,
+      start: lines.first,
+      end: lines.last
+    }
+  end
+end

data/lib/tracer.rb

@@ -0,0 +1,44 @@
+require "linguist"
+
+require_relative "ruby_tracer"
+require_relative "c_syntax_tracer"
+require_relative "python_tracer"
+
+class VirtualBlob < Linguist::FileBlob
+  def initialize(path, data)
+    @path = path
+    @data = data
+  end
+
+  def data
+    @data
+  end
+
+  def size
+    @size ||= data.length
+  end
+end
+
+class Tracer
+  def trace(path, code)
+    case recognize(path, code)
+    when "ruby"
+      RubyTracer.new.trace(code)
+    when "php", "javascript"
+      CSyntaxTracer.new.trace(code)
+    when "python"
+      PythonTracer.new.trace(code)
+    else
+      []
+    end
+  end
+
+  private
+
+  def recognize(path, code)
+    Linguist
+      .detect(VirtualBlob.new(path, code))
+      &.name
+      &.downcase
+  end
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: whatbug
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Brian Yahn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-01-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.1.1
+- !ruby/object:Gem::Dependency
+  name: github-linguist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.3.2
+description: WhatBug helps you find where a bug was introduced faster by finding all
+  lines of code in the relevant functions of a stack trace and identifying which of
+  those have changed within a timeframe.
+email: yahn007@outlook.com
+executables:
+- whatbug
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/whatbug
+- lib/airbrake_client.rb
+- lib/c_syntax_tracer.rb
+- lib/git_client.rb
+- lib/python_tracer.rb
+- lib/rollbar_client.rb
+- lib/ruby_tracer.rb
+- lib/tracer.rb
+homepage: https://github.com/cuzzo/whatbug
+licenses:
+- BSD-2-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Find the source of the bug with WhatBug
+test_files: []