rorvswild 1.7.1 → 1.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 587f67697724c84547a0fde87674a10b35b4a36c61d5de4d032bd775fa339443
-  data.tar.gz: 5da27bd25a15ba85948731d383084852778545a7a86c95921194c22bf80efc7e
+  metadata.gz: d947482c8e791eebcf34ce670f5b35f4f6aa4bf547fec308119ed18839cfae4a
+  data.tar.gz: 87f8a8ed97ea66cdc405209c92d03a637471b4507a22179ca2dde273f183ecda
 SHA512:
-  metadata.gz: 92cef045840fe613886cd7d2fd8370cf69afff5e86517025efaaf33d2e694c629225cd82dd728cbf8d1f89045119479dc7667ad44cb1cf935131e84e0720b067
-  data.tar.gz: 127d539486858d0f73ad38cb5ab4c2164c43b56c01673e114f08760e0a394b70be2bc569a0b332a7bc901347a05066d84e7407f772dd6c46ae227584930cdc49
+  metadata.gz: 909542f1359138d44c8b8cec6ac8599e5b8e3eafb5d1eb27de0099be040a06e9753ff4068ba0b7f706c4b080aae18b7d340054679e9a6235fc82f8db05a0e0ea
+  data.tar.gz: '080bdc4b330af84eb7aad989588a93a46b672c22725d8d6c534befddce6178765961b716915808bd7e4fe08d5d44f47c747402133573fce9135a9958fab92d25'

data/lib/rorvswild/agent.rb

@@ -61,12 +61,34 @@ module RorVsWild
       current_data ? measure_section(name, kind: kind, &block) : measure_job(name, &block)
     end
 
-    def measure_section(name, kind: "code", appendable_command: false, &block)
+    def measure_method(method)
+      return if method.name.end_with?("_measured_by_rorvswild")
+      if method.is_a?(Method)
+        method_full_name = [method.receiver, method.name].join(".") # Method => class method
+      else
+        method_full_name = [method.owner, method.name].join("#") # UnboundMethod => instance method
+      end
+      method_alias = :"#{method.name}_measured_by_rorvswild"
+      return if method.owner.method_defined?(method_alias)
+      method.owner.alias_method(method_alias, method.name)
+      method_file, method_line = method.source_location
+      method_file = locator.relative_path(File.expand_path(method_file))
+      method.owner.define_method(method.name) do |*args|
+        section = Section.start
+        section.file = method_file
+        section.line = method_line
+        section.commands << method_full_name
+        result = send(method_alias, *args)
+        Section.stop
+        result
+      end
+    end
+
+    def measure_section(name, kind: "code", &block)
       return block.call unless current_data
       begin
         RorVsWild::Section.start do |section|
-          section.appendable_command = appendable_command
-          section.command = name
+          section.commands << name
           section.kind = kind
         end
         block.call
@@ -85,6 +107,8 @@ module RorVsWild
         push_exception(ex, parameters: parameters, job: {name: name})
         raise
       ensure
+        gc = Section.stop_gc_timing(current_data[:gc_section])
+        current_data[:sections] << gc if gc.calls > 0
         current_data[:runtime] = RorVsWild.clock_milliseconds - current_data[:started_at]
         queue_job
       end
@@ -95,8 +119,10 @@ module RorVsWild
     end
 
     def stop_request
-      return unless current_data
-      current_data[:runtime] = RorVsWild.clock_milliseconds - current_data[:started_at]
+      return unless data = current_data
+      gc = Section.stop_gc_timing(data[:gc_section])
+      data[:sections] << gc if gc.calls > 0 && gc.total_ms > 0
+      data[:runtime] = RorVsWild.clock_milliseconds - current_data[:started_at]
       queue_request
     end
 
@@ -110,7 +136,7 @@ module RorVsWild
     end
 
     def record_error(exception, context = nil)
-      send_error(exception_to_hash(exception, context)) if !ignored_exception?(exception)
+      queue_error(exception_to_hash(exception, context)) if !ignored_exception?(exception)
     end
 
     def push_exception(exception, options = nil)
@@ -171,10 +197,11 @@ module RorVsWild
 
     def initialize_data
       Thread.current[:rorvswild_data] = {
-        sections: [],
-        section_stack: [],
-        environment: Host.to_h,
         started_at: RorVsWild.clock_milliseconds,
+        gc_section: Section.start_gc_timing,
+        environment: Host.to_h,
+        section_stack: [],
+        sections: [],
       }
     end
 
@@ -193,8 +220,8 @@ module RorVsWild
       queue.push_job(cleanup_data)
     end
 
-    def send_error(hash)
-      client.post_async("/errors".freeze, error: hash)
+    def queue_error(hash)
+      queue.push_error(hash)
     end
 
     def exception_to_hash(exception, context = nil)

data/lib/rorvswild/local/javascript/local.js

@@ -2,24 +2,47 @@ var RorVsWild = this.RorVsWild = {};
 
 RorVsWild.Local = function(container) {
   this.root = container
-  this.embedded = !(this.active = location.pathname == "/rorvswild")
-  RorVsWild.Local.editorUrl = container.getAttribute("data-editor-url")
-  this.fetchData()
+  this.active = false
+  RorVsWild.Local.editorUrl = container.dataset.editorUrl
+  if (this.embedded = location.pathname != "/rorvswild")
+    window.addEventListener("keydown", this.keydown.bind(this))
+  else
+    this.active = true
+  this.goToRequestIndex()
+}
+
+RorVsWild.Local.prototype.getRequests = function(callback) {
+  this.getJson("/rorvswild/requests.json", function(data) {
+    this.requests = data.map(function(attributes) { return new RorVsWild.Local.Request(attributes) })
+    callback()
+  }.bind(this))
+}
+
+RorVsWild.Local.prototype.getJobs = function(callback) {
+  this.getJson("/rorvswild/jobs.json", function(data) {
+    this.jobs = data.map(function(attributes) { return new RorVsWild.Local.Request(attributes) })
+    callback()
+  }.bind(this))
+}
+
+RorVsWild.Local.prototype.getErrors = function(callback) {
+  this.getJson("/rorvswild/errors.json", function(data) {
+    this.errors = data.map(function(attributes) { return new RorVsWild.Local.Error(attributes) })
+    callback()
+  }.bind(this))
 }
 
-RorVsWild.Local.prototype.fetchData = function() {
+RorVsWild.Local.prototype.getJson = function(path, callback) {
   var request = new XMLHttpRequest()
-  request.open("GET", "/rorvswild.json", true)
+  request.open("GET", path, true)
 
   request.onload = function(event) {
     if (request.status >= 200 && request.status < 400) {
-      this.data = JSON.parse(request.response)
-      this.requests = this.data.map(function(data) { return new RorVsWild.Local.Request(data) })
-      this.render()
+      callback(JSON.parse(request.response))
     } else {
       console.error("Unexpected response code " + request.status + " while fetching RorVswild data.")
     }
-  }.bind(this)
+  }
 
   request.onerror = function() {
     console.error("Error while fetching RorVswild data.")
@@ -28,33 +51,37 @@ RorVsWild.Local.prototype.fetchData = function() {
   request.send()
 }
 
-RorVsWild.Local.prototype.render = function() {
+RorVsWild.Local.prototype.render = function(view) {
+  this.view = view
   Barber.render("RorVsWild.Local", this, this.root)
   Prism.highlightAllUnder(this.root)
 }
 
+RorVsWild.Local.prototype.renderBody = function() {
+  var templates = Barber.partials()
+  return Mustache.render(templates["RorVsWild.Local." + this.view], this, templates)
+}
+
 RorVsWild.Local.prototype.lastRuntime = function() {
   return this.requests[0] ? this.requests[0].runtime() : "N/A"
 }
 
-RorVsWild.Local.prototype.toggle = function() {
-  this.active ? this.collapse() : this.expand()
+RorVsWild.Local.prototype.toggle = function(event) {
+  this.active ? this.collapse() : this.expand(event)
 }
 
 RorVsWild.Local.prototype.toggleCommand = function(event) {
-  document.querySelector(event.currentTarget.getAttribute("data-target")).classList.toggle("is-open")
+  document.querySelector(event.currentTarget.dataset.target).classList.toggle("is-open")
 }
 
 RorVsWild.Local.prototype.expand = function() {
-  this.currentRequest = this.requests[0]
   this.active = true
-  this.render()
-  window.addEventListener("keydown", this.keydown.bind(this))
+  this.goToRequestDetail(event)
 }
 
 RorVsWild.Local.prototype.collapse = function() {
   this.active = false
-  this.render()
+  this.goToRequestIndex()
 }
 
 RorVsWild.Local.prototype.keydown = function(event) {
@@ -62,8 +89,17 @@ RorVsWild.Local.prototype.keydown = function(event) {
     this.collapse()
 }
 
-RorVsWild.Local.formatRuntime = function(runtime) {
-  return runtime > 0 && runtime < 1 ? "<1" : Math.round(runtime)
+RorVsWild.Local.relevantRounding = function(value) {
+  if (!value || value == 0)
+    return 0
+  else if (value < 0.01)
+    return value
+  else if (value < 1)
+    return Number(value.toFixed(2))
+  else if (value < 10)
+    return Number(value.toFixed(1))
+  else
+    return Number(value.toFixed(0))
 }
 
 RorVsWild.Local.formatImpact = function(impact) {
@@ -77,15 +113,38 @@ RorVsWild.Local.formatDateTime = function(date) {
   return [date.getDate(), months[date.getMonth()], hours + ":" + minutes].join(" ")
 }
 
-RorVsWild.Local.prototype.goToRequestDetails = function(event) {
-  var id = parseInt(event.currentTarget.getAttribute("data-request-id"))
-  this.currentRequest = this.requests.find(function(req) { return req.id == id })
-  this.render()
+RorVsWild.Local.prototype.goToRequestDetail = function(event) {
+  this.root.dataset.tab = "requests"
+  var uuid = event.currentTarget.dataset.uuid
+  this.currentRequest = this.requests.find(function(req) { return req.uuid == uuid })
+  this.render("RequestDetail")
+}
+
+RorVsWild.Local.prototype.goToRequestIndex = function(event) {
+  this.root.dataset.tab = "requests"
+  this.getRequests(function() { this.render("RequestIndex") }.bind(this))
+}
+
+RorVsWild.Local.prototype.goToJobIndex = function(event) {
+  this.root.dataset.tab = "jobs"
+  this.getJobs(function() { this.render("JobIndex") }.bind(this))
+}
+
+RorVsWild.Local.prototype.goToJobDetail = function(event) {
+  var uuid = event.currentTarget.dataset.uuid
+  this.currentJob = this.jobs.find(function(job) { return job.uuid == uuid })
+  this.render("JobDetail")
+}
+
+RorVsWild.Local.prototype.goToErrors = function(event) {
+  this.root.dataset.tab = "errors"
+  this.getErrors(function() { this.render("ErrorIndex") }.bind(this))
 }
 
-RorVsWild.Local.prototype.goToHistory = function(event) {
-  this.currentRequest = null
-  this.render()
+RorVsWild.Local.prototype.goToErrorDetail = function(event) {
+  var uuid = event.currentTarget.dataset.uuid
+  this.currentError = this.errors.find(function(err) { return err.uuid == uuid })
+  this.render("ErrorDetail")
 }
 
 RorVsWild.Local.prototype.containerClass = function() {
@@ -102,6 +161,13 @@ RorVsWild.Local.kindToLanguage = function(kind) {
   }
 }
 
+RorVsWild.Local.pathToUrl = function(cwd, file, line) {
+  if (RorVsWild.Local.editorUrl) {
+    var path = file[0] == "/" ? file : cwd + "/" + file
+    return RorVsWild.Local.editorUrl.replace("${path}", path).replace("${line}", line)
+  }
+}
+
 RorVsWild.Local.lastId = 0
 
 RorVsWild.Local.nextId = function() {
@@ -109,15 +175,15 @@ RorVsWild.Local.nextId = function() {
 }
 
 RorVsWild.Local.Request = function(data) {
-  this.id = RorVsWild.Local.nextId()
   this.data = data
+  this.uuid = data.uuid
   this.name = data.name
   this.path = data.path
   this.queuedAt = RorVsWild.Local.formatDateTime(new Date(data.queued_at))
 }
 
 RorVsWild.Local.Request.prototype.runtime = function() {
-  return RorVsWild.Local.formatRuntime(this.data.runtime)
+  return RorVsWild.Local.relevantRounding(this.data.runtime)
 }
 
 RorVsWild.Local.Request.prototype.sections = function() {
@@ -126,19 +192,118 @@ RorVsWild.Local.Request.prototype.sections = function() {
     var object = {
       id: RorVsWild.Local.nextId(),
       impact: RorVsWild.Local.formatImpact(runtime * 100 / this.data.runtime),
-      averageRuntime: RorVsWild.Local.formatRuntime(runtime / section.calls),
+      language: RorVsWild.Local.kindToLanguage(section.kind),
+      totalRuntime: RorVsWild.Local.relevantRounding(section.total_runtime),
+      childrenRuntime: RorVsWild.Local.relevantRounding(section.children_runtime),
+      selfRuntime: RorVsWild.Local.relevantRounding(runtime),
+      runtime: RorVsWild.Local.relevantRounding(runtime),
+      averageRuntime: RorVsWild.Local.relevantRounding(runtime / section.calls),
       command: section.kind != "view" ? section.command : null,
       calls: section.calls,
       kind: section.kind.substring(0, 7),
       file: section.file,
       line: section.line,
-      runtime: runtime,
-      language: RorVsWild.Local.kindToLanguage(section.kind),
-    }
-    if (RorVsWild.Local.editorUrl) {
-      var path = section.file[0] == "/" ? section.file : this.data.environment.cwd + "/" + section.file
-      object.url = RorVsWild.Local.editorUrl.replace("${path}", path).replace("${line}", section.line)
+      location: section.kind == "view" ? section.file : section.file + ":" + section.line,
+      locationUrl: RorVsWild.Local.pathToUrl(this.data.environment.cwd, section.file, section.line)
     }
     return object
-  }.bind(this)).sort(function(a, b) { return b.runtime - a.runtime })
+  }.bind(this)).sort(function(a, b) { return b.selfRuntime - a.selfRuntime })
+}
+
+RorVsWild.Local.Request.prototype.sectionsImpactPerKind = function() {
+  var total = 0
+  var perKind = this.sections().reduce(function(object, section) {
+    object[section.kind] = (object[section.kind] || 0) + section.runtime
+    total += section.runtime
+    return object
+  }, {})
+  return Object.entries(perKind).sort(function(a, b) { return b[1] - a[1] })
+    .map(function(item) { return {kind: item[0], impact: Math.round((item[1] / total * 100) * 10) / 10} })
+}
+
+RorVsWild.Local.Error = function(data) {
+  this.data = data
+  this.backtrace = data.backtrace
+  this.context = data.context
+  this.environment = data.environment
+  this.exception = data.exception
+  this.message = data.message
+  this.file = data.file
+  this.line = data.line
+  this.locationUrl = RorVsWild.Local.pathToUrl(data.environment.cwd, data.file, data.line)
+  this.message = data.message
+  this.queuedAt = RorVsWild.Local.formatDateTime(new Date(data.queued_at))
+  this.uuid = data.uuid
+  this.parameters = data.parameters
+  this.request = data.request
+  this.job = data.job
+}
+
+RorVsWild.Local.Error.prototype.shortMessage = function() {
+  return this.message.length < 160 ? this.message : this.message.substring(0, 160) + "…"
+}
+
+RorVsWild.Local.Error.prototype.hasRequest = function() {
+  return this.request != null
+}
+
+RorVsWild.Local.Error.prototype.eachRequestProperty = function() {
+  return this.request && this.objectToProperties(this.request)
+}
+
+RorVsWild.Local.Error.prototype.hasParameters = function() {
+  return this.parameters != null
+}
+
+RorVsWild.Local.Error.prototype.parametersInJson = function() {
+  return JSON.stringify(this.parameters, null, 2)
+}
+
+RorVsWild.Local.Error.prototype.hasRequestHeaders = function() {
+  return this.request && this.request.headers != null
+}
+
+RorVsWild.Local.Error.prototype.eachRequestHeader = function() {
+  return this.request && this.request.headers && this.objectToProperties(this.request.headers)
+}
+
+RorVsWild.Local.Error.prototype.eachEnvironment = function() {
+  return this.objectToProperties(this.environment)
+}
+
+RorVsWild.Local.Error.prototype.hasContext = function() {
+  return this.context != null
+}
+
+RorVsWild.Local.Error.prototype.eachContext = function() {
+  return this.objectToProperties(this.context)
+}
+
+RorVsWild.Local.Error.prototype.objectToProperties = function(object) {
+  var array = []
+  for (var name in object)
+    if (object.hasOwnProperty(name))
+      array.push({name: name, value: object[name]})
+  return array
+}
+
+RorVsWild.Local.Error.prototype.compactBacktrace = function() {
+  var cwd = this.environment.cwd
+  cwd.endsWith("/") || (cwd += "/")
+  var vendorPath = (cwd + "vendor/bundle")
+  return this.backtrace.filter(function(path) {
+    return path.startsWith(cwd) && !path.startsWith(vendorPath)
+  }).map(function(path) { return path.replace(cwd, "") }).join("\n")
+}
+
+RorVsWild.Local.Error.prototype.compactBacktraceLocations = function() {
+  var cwd = this.environment.cwd
+  return this.compactBacktrace().split("\n").map(function(path) {
+    var fileAndLine = path.split(":")
+    return {path: path, url: RorVsWild.Local.pathToUrl(cwd, fileAndLine[0], fileAndLine[1])}
+  })
+}
+
+RorVsWild.Local.Error.prototype.formattedBacktrace = function() {
+  return this.backtrace.join("\n")
 }