rorvswild 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dbddf42d7a3d87901206dcdb0872b689c733b100
-  data.tar.gz: 51c9aeebb5d2ec07863465db44f2253990421336
+  metadata.gz: 539fb2b080805724e336dc4d11c5321c4dccde4e
+  data.tar.gz: 7564c5063da3e4e140a1ead81da5273379966207
 SHA512:
-  metadata.gz: 1b109fabeb568743f2d306c8295bdb4201fa01773fb0940c9c2c8ebe1679426fe91969d56fa3c6c02217ef91e9f4241b23eac881a68ef276f6354b86c4eb69f4
-  data.tar.gz: e20ff2a1eae18fbaa31e4631f7a6093ce7b97be390ddc0acea6a6e6483820a1cefe7737572a439c90442d8299c79a119998c9ba33fee635f90d4c3194fadc8d4
+  metadata.gz: 9cc49fe8204ad12061a1c9995f81ad6d96b0352e5789abd3d762755d1caeb12ff10ee11442c13bef624bebfcf6d49be62838911e8ab4577a820460865850781d
+  data.tar.gz: d58eb06d7bd4004b9ee7964f07f98a1e512fe9a99cc315afff18f200708d4a04b81f2bf4645740940d7b98f247a08889e675e275168d695fbe78ade449d4c2ef

data/README.md

@@ -1,17 +1,40 @@
+
 # RorVsWild
 
-Ruby on Rails app monitoring: performances & quality insights for rails developers.
+<img align="right" src="/images/rorvswild_logo.jpg">
+
+*RoRvsWild* is a free ruby gem to monitor performances and quality in Ruby on Rails applications.
+
+This gem has a double mode, development and production.
+It can be used without an account to monitor your requests performances in your development environment.
+It can also be used in your production and staging environments with an account on https://rorvswild.com. With such an account you also get extra benefits such as 30 day trace, background jobs monitoring, errors monitoring and notifications.
+
 
 ## Installation
 
-First you need an API key. Signup here https://www.rorvswild.com to get one and a 14 day free trial.
+#### Install the gem
+
+* Add in your Gemfile `gem "rorvswild"`
+* Run `bundle install` in you terminal
+* Restart your local server and you’ll see a small button in the bottom left corner of your page.
+
+![RoRvsWild Local Button](/images/rorvswild_local_button.jpg)
 
-1. Add in your Gemfile `gem "rorvswild"`
-2. Run `bundle install`
-3. Run `rorvswild-setup API_KEY`
-4. Restart / deploy your app !
+This is all what you need to do to monitor your local environment requests.
+
+#### API key
+
+**To monitor your production or staging environment, you need an API key.**
+Signup on https://www.rorvswild.com and create an app to get one.
+
+* Add in your Gemfile `gem "rorvswild"`
+* Run `bundle install` in you terminal
+* Run `rorvswild-setup API_KEY` in you terminal
+* Deploy/Restart your app
+* Make a few requests and refresh your app page on rorvswild.com to view the dashboard.
+
+The `rorvswild-setup` command creates a `config/rorvswild.yml` file.
 
-The `rorvswild-setup` create a `config/rorvswild.yml` file.
 For those who prefer to manually use an initializer, they can do the following.
 
 ```ruby
@@ -19,7 +42,36 @@ For those who prefer to manually use an initializer, they can do the following.
 RorVsWild.start(api_key: API_KEY)
 ```
 
-## Measure any code
+You can create unlimited apps on *rorvswild.com* to monitor your different environments, or use the same key for both staging and production. If you want to add a staging server you have to edit your Gemfile.
+
+## Development mode: *RoRvsWild Local*
+
+![RoRvsWild Local](/images/rorvswild_local.jpg)
+
+*RorVsWild Local* monitors the performances of requests in development environment.
+It shows most of the requests performances insights *RoRvsWild.com* displays. **A big difference is everything works locally and no data is sent and recorded on our servers**. You don’t even need an account to use it.
+
+*RoRvsWild Local* renders a small button in the bottom left corner of your page showing the runtime of the current request. If you click on it, you get all the profiled sections ordered by impact, which is depending on the sections average runtime and the calls count. As on RoRvsWild.com, the bottleneck is always on the top of the list.
+
+Be aware that the performances on your development machine may vary from the production server. Obviously because of the different hardware and database size. Also, Rails is reloading all the code in development environment and this takes quite a lot of time.
+To prevent this behaviour and better match the production, turn on cache_classes in your config/environments/development.rb:
+
+```
+Rails.application.configure do
+  config.cache_classes = true
+end
+```
+
+If you are using `Rack::Deflater` middleware you won't see the small button in the corner. Because of the compression it is not possible to inject some JavaScript into the page. In that case visit http://localhost:3000/rorvswild to see the profiler.
+
+## Production mode: *RoRvsWild.com*
+
+![RoRvsWild.com](/images/rorvswild_prod.jpg)
+
+*RoRvsWild.com* makes it easy to monitor requests, background jobs and errors in your production and staging environment.
+It also comes with some extra options listed below.
+
+#### Measure any code
 
 You can measure any code like this (useful to monitor cronjobs):
 
@@ -33,12 +85,12 @@ Or like that:
 RorVsWild.measure_block("A great job name") { User.all.do_something_great }
 ```
 
-Then it will appears in the jobs page.
+Then it will appear in the jobs page.
 
 Note that Calling `measure_code` or `measure_block` inside or a request or a job will add a section.
 That is convenient to profile finely parts of your code.
 
-## Send errors manually
+#### Send errors manually
 
 When you already have a begin / rescue block, this manner suits well:
 
@@ -66,9 +118,9 @@ RorVsWild.record_error(exception, {something: "important"})
 RorVsWild.catch_error(something: "important") { 1 / 0 }
 ```
 
-## Ignore exceptions
+#### Ignore exceptions
 
-By using the ignored_exceptions parameter you can prevent RorVsWild from recording specific exceptions.
+By using the ignored_exceptions parameter you can prevent *RoRvsWild* from recording specific exceptions.
 
 ```yaml
 # config/rorvswild.yml

data/lib/rorvswild/agent.rb

@@ -20,7 +20,7 @@ module RorVsWild
       @ignored_exceptions = config[:ignored_exceptions]
       @app_root = config[:app_root]
       @client = Client.new(config)
-      @queue = Queue.new(client)
+      @queue = config[:queue] || Queue.new(client)
       cleanup_data
 
       if defined?(Rails)

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

@@ -0,0 +1,67 @@
+var Mustache = this.Mustache
+var Barber = this.Barber = {}
+
+Barber.launch = function(root, namespace) {
+  var elements = (root || document).querySelectorAll("[data-barber]")
+  Array.prototype.forEach.call(elements, function(element) { Barber.start(element, namespace) })
+}
+
+Barber.start = function(element, namespace) {
+  var name = element.getAttribute("data-barber")
+  var func = Barber.stringToFunction(name, namespace)
+  if (func instanceof Function)
+    Barber.instanciate(func, element)
+  else
+    console.warn("View " + name + " is not a function.")
+}
+
+Barber.instanciate = function(func, element) {
+  try {
+    view = new func(element)
+  } catch (ex) {
+    console.error(ex)
+  }
+}
+
+Barber.stringToFunction = function(fullName, parent) {
+  var func = parent || window
+  var names =  fullName.split(".")
+  for (var i = 0; i < names.length; i++)
+    if (!(func = func[names[i]]))
+      return null
+  return func
+}
+
+Barber.render = function(name, view, element) {
+  var partials = Barber.partials()
+  if (!partials[name]) {
+    console.error("Partial " + name + " does not exists.")
+    return
+  }
+  element.innerHTML = Mustache.render(partials[name], view, partials)
+  Barber.listenEvents(element, view)
+}
+
+Barber.partials = function() {
+  var elements = document.querySelectorAll('[type="x-tmpl-mustache"][data-partial]')
+  return Array.prototype.reduce.call(elements, function(hash, element) {
+    hash[element.getAttribute("data-partial")] = element.innerHTML
+    return hash
+  }, {})
+}
+
+Barber.listenEvents = function(root, view) {
+  root.querySelectorAll("[data-events]").forEach(function(element) {
+    element.getAttribute("data-events").split(" ").forEach(function(eventAndAction) {
+      var array = eventAndAction.split("->")
+      Barber.listenEvent(view, element, array[0], array[1])
+    })
+  })
+}
+
+Barber.listenEvent = function(view, element, event, action) {
+  if (view[action] instanceof Function)
+    element.addEventListener(event, view[action].bind(view))
+  else
+    console.warn("Action " + view.constructor.name + "." + action + " is not a function.")
+}

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

@@ -0,0 +1,108 @@
+var RorVsWild = this.RorVsWild = {};
+
+RorVsWild.Local = function(container) {
+  this.root = container
+  this.embedded = !(this.active = location.pathname == "/rorvswild")
+  this.data = JSON.parse((this.container = container).getAttribute("data-json"))
+  this.requests = this.data.map(function(data) { return new RorVsWild.Local.Request(data) })
+  this.render()
+}
+
+RorVsWild.Local.prototype.render = function() {
+  Barber.render("RorVsWild.Local", this, this.root)
+  Prism.highlightAllUnder(this.root)
+}
+
+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.expand = function() {
+  this.currentRequest = this.requests[0]
+  this.active = true
+  this.render()
+}
+
+RorVsWild.Local.prototype.collapse = function() {
+  this.active = false
+  this.render()
+}
+
+RorVsWild.Local.formatRuntime = function(runtime) {
+  return runtime > 0 && runtime < 1 ? "<1" : Math.round(runtime)
+}
+
+RorVsWild.Local.formatImpact = function(impact) {
+  return impact > 0 && impact < 1 ? "<1" : Math.round(impact)
+}
+
+RorVsWild.Local.formatDateTime = function(date) {
+  var months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+  var minutes = date.getMinutes() < 10 ? "0" + date.getMinutes() : date.getMinutes()
+  var hours = date.getHours() < 10 ? "0" +  date.getHours() : date.getHours()
+  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.goToHistory = function(event) {
+  this.currentRequest = null
+  this.render()
+}
+
+RorVsWild.Local.prototype.containerStyle = function() {
+  if (!this.active)
+    return 'display: none !important;'
+}
+
+RorVsWild.Local.kindToLanguage = function(kind) {
+  switch (kind) {
+    case "sql": return "language-sql"
+    case "mongo": return "language-javascript"
+    case "elasticsearch": return "language-json"
+    default: return "language-none"
+  }
+}
+
+RorVsWild.Local.lastId = 0
+
+RorVsWild.Local.nextId = function() {
+  return RorVsWild.Local.lastId += 1
+}
+
+RorVsWild.Local.Request = function(data) {
+  this.id = RorVsWild.Local.nextId()
+  this.data = data
+  this.name = data.name
+  this.path = data.path
+  this.startedAt = RorVsWild.Local.formatDateTime(new Date(data.started_at))
+}
+
+RorVsWild.Local.Request.prototype.runtime = function() {
+  return RorVsWild.Local.formatRuntime(this.data.runtime)
+}
+
+RorVsWild.Local.Request.prototype.sections = function() {
+  return this.data.sections.map(function(section) {
+    var runtime = (section.total_runtime - section.children_runtime)
+    return {
+      impact: RorVsWild.Local.formatImpact(runtime * 100 / this.data.runtime),
+      averageRuntime: RorVsWild.Local.formatRuntime(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),
+    }
+  }.bind(this)).sort(function(a, b) { return b.runtime - a.runtime })
+}