wor-prof 0.1.0

data/doc/user-guide_en.md

@@ -0,0 +1,308 @@
+# Wor-Prof
+
+Wor-prof (Wprof) is a gem for Ruby On Rails which its only purpose is to measure a RoR app's performance through a profile with different times of response. In order to accomplish that, Wprof uses ActiveSupport::Notifications (available in Rails since v4.0.2) to capture every action from his controllers. However, there's more. when using httparty in your project, you can capture every done request to external services. Do you have one or two methods that would like to know how long they take to execute? With Wprof you can find out.
+
+Then, every data obtained can be reported in several ways, choose one from the Rails logger: database file, CSV text or go ahead and do a Post request wherever you want... Do it both synchronously or asynchronously.
+
+---
+
+## Let's begin.
+
+The first step is the gem install (of course) and the way to do it is well known. However, just in case, you'll find the steps to follow next.
+
+### Installation 
+
+Add the next line to the gemfile from your Rails application:
+
+```ruby
+gem 'wor-prof'
+```
+
+And then, execute:
+```bash
+$ bundle install
+```
+**That's it!!** At server execution, WProf immediately begins to work with default settings, so you won't need to configure anything if it matches with your needs, otherwise you can check **Available Settings**.
+
+---
+
+## Register Types and how they works.
+
+As register types, Wprof counts with the following.
+
+* Controllers: every request realized to Rails' App that is handled by a Controller. (this is a default setting and cannot be disabled)
+* HTTParty: every time an HTTParty method is involved.
+* Own methods: an array of methods can be defined to be captured.
+``Only "controllers" are automatically profiled by just adding the gem, every other one will need an extra configuration or operation.``
+
+### HTTparty
+
+HTTParty is a popular tool for Ruby that allows to easily make HTTP's requests.
+If you're not used to the gem I recommend you to read more information in its repository, right [here!](https://github.com/jnunemaker/httparty)
+
+In order to profile the requests made by  HTTParty, you must include Wprof right after Httparty. This is:
+
+```ruby
+class FooClass
+    include HTTParty
+    include Wprof
+```
+What that does mean? Wprof make a wrapper over every called method as class methods, waits for the response and captures some of the needed data to generate the profile. This is why you **must include the module right after HTTParty**... Otherwise, it would simply not work.
+
+By default, WProf defines the methods that are commonly used to generate a request (Get, Put, Delete, Post), however you can define or exclude some of that list. It's **strongly recommended not to add** HTTParty's methods without being completely certain that the result is what WProf will try to capture (See 'captured Data' to know which are they)
+
+### Own methods
+
+Sometimes it may result useful to know how much an specific method is taking to execute, to this end Wor-prof can help you out.
+
+There are two steps to accomplish that.
+
+1. Prepare an array of methods which you want to trace (check configuration section: "custom_methods")
+2. Include WProf to that method's class
+
+Done, with this WProf will be registering the execution time of said method every time is being called and then it will report it.
+
+---
+
+## Available Configurations.
+
+WProf contains a list of default settings which can all be altered by others availables as user's preferences demands. In order to do that, create a file in 'config/initializers' (RailsApp.Root >> config >> initializers >> wprof.rb). Inside, you must define the following configuration:
+
+```ruby
+Rails.application.configure do
+  config.x.wprof.db_runtime = true
+  config.x.wprof.reporter_type = 'FILE'
+end
+```
+> In case of not correctly configuring an option or just skip it, the value would be default.
+
+To avoid this configuration manually using the **configuration generator** with the command "rails generate wprof" (see generator section).
+
+Following the complete list of available settings and their meaning.
+
+### config.x.wprof.db_runtime
+Sets whether it shows or not the data "db_runtime" inside the report.
+
+> Possible values: true o false
+
+> Default: true
+
+### config.x.wprof.reporter_type 
+Sets report type, meaning, how to show the obtained data. There are currently 4 available types, see "Reports" section for more information.
+
+> Possible values: LOGGER, FILE, DATABASE, EXTERNAL
+
+> Default: LOGGER
+
+### config.x.wprof.csv_type
+When the report is defined as a CSV file there are two ways of generate it.
+* **MIX:** generates one CSV file where every data captured by WProf is saved. This file only contains 2 columns: in the first one is the field and in the second one the data.
+* **SPLIT:** Divides storage in three different files, one for each record type. This significantly improves reading since every field is held as the file's header and the data in rows is split by comma... As it should be, of course... Why mix then?, I don't know, it could be useful for someone!
+> Possible values: MIX, SPLIT.
+> Default: SPLIT
+
+### config.x.wprof.async
+Sets whether the report is being generated sinchronously or not. **Take note: asynchronous mode requires extra steps, see "asynchronism" section for more information.**
+> Possible values: false, true
+> Default: false
+
+### config.x.wprof.httparty_methods_to_trace
+HTTParty's method captured by WProf. By default, more common ones are set and it's recommended not to modify.
+This being said, there's no problem in taking out some of the array, however take special care in adding HTTParty's methods which doesn't return an http request.
+> Possible values: what you want and need, must be an **array of strings**.
+> Default: ['get', 'put', 'delete', 'post']
+
+### config.x.wprof.external_url
+In case you configure reporter_type as External, you must indicate the URL which will receive the HTTP petition.
+> Possible values: any string that corresponds to an URL. Example: 'http://example-url/reporter'
+> Default: nil
+
+### config.x.wprof.external_headers
+To add a header to the http request ("external" report type), you must define it in this setting. This must be a **HASH of RUBY**, exactly as HTTParty expects (internally Wprof uses HTTParty to send a request). An example would be:
+
+``` ruby
+config.x.wprof.external_headers = { headers: {'User-Agent' => 'Httparty'}}
+```
+> Possible : Any valid hash, must respect primary key as "headers" (check example below)
+> Default: nil
+
+### config.x.wprof.custom_methods
+If you want to capture response times of an specific method inside a class, it's not enough including the module, you'll need to indicate WProf exactly which is the one it has to capture.
+This list of methods must be contained in this option in a **array of Ruby** and it has to be strings.
+Example:
+``` ruby
+config.x.wprof.custom_methods = [ 'my_great_method' ]
+```
+> Possible values: any method's name in string format, within an array.  Default: nil
+
+### config.x.wprof.file_path
+
+When "FILE" is used as an output, this option allows you to choose the files destination. This must be a valid route, as string, with reading permission for Rails and also be a folder.
+Example: 
+``` ruby
+config.x.wprof.file_path = '/home/mcolombo/examplefolder'
+```
+> Possible values: any string that correctly represents a PATH to a directory.
+> Default: Rails.root is used, so, root is Rails application.
+
+---
+
+## Generators.
+
+WProf has two Rails generators availables.
+
+---
+
+### Configuration file Generator.
+
+To begin to modify options from available settings, you must create a config file inside the 'config/initializers' (as mentioned in "available configurations" section). To avoid unnecessary steps and possible mistakes in the well known dangerous 'copy/paste', you can generate this file as a template with the following Rails command:
+
+```
+rails generate wprof
+```
+This generates a model of the configuration's file with all the available options seen in "available configurations" section.
+
+### Data Model Generator
+
+An available option to report captured information is the same database Rails uses, the problem is, this requires defining the model. This generator will create all of the migration files and the models for using this option without having to worry for anything else.
+```
+rails generate wprof_model
+```
+This will generate the migration files and the models (even controllers in case you want to handle them!) 
+**Remember: in order to models be available in the case you still must run the migration.**
+```
+rails db:migrate
+```
+
+---
+
+## Captured Data.
+
+Data captured and reported by WProf vary depending on which record they come, although, all of them share some base data.
+
+### Base data (common to all)
+
+* **transaction_id:** unique identifier for each transaction. This field is vital due to HTTParty's records and methods share this same identifier with the request that triggered this execution, allowing a complete execution trace of each one of them.
+* **total_time:** Total execution time registered (in milliseconds).
+* **start_dt:** Date and time field when register began.
+* **end_dt:** Date and time field when register ended.
+
+### Unique for the controller.
+
+* **code:** Response code sensed by the controller (Status), eg. 200, 404, etc.
+* **controller:** Controller that handled the request.
+* **url:** Endpoint that received the petition.
+* **db_runtime:** total time when it was absorbed by the database (included in total_time).
+
+### Únicos para los Servicios (Httparty).
+
+* **code:** Código de respuesta recibido (Status), ej. 200, 404, etc.
+* **service_hostname:** Hostname del servicio consumido.
+* **request_uri:** Uri del endpoint consumido.
+
+### Unique for services (Httparty).
+
+* **method:** measured method's name.
+
+---
+
+## Reports.
+
+Destination of the data, once is captured and processed, varies in order of user’s preferences Wor-Prof offers the following destinations for the information:
+* **LOGGER:** Uses Rails.logger to show the information.
+* **FILE:** Saves the info in one or several text files, split by comma (csv)
+* **DATABASE:** Saves obtained data in the same database used by Rails (requires model preparation, see generator/s of data model)
+* **EXTERNAL:** Does a POST petition with the data sended in the body in a JSON format (requires additional configuration)
+
+> "Logger" as well as "File" don’t need additional configuration to work, however “Database” and “External” require some previous step.
+
+### Database Reporter
+
+For **DATABASE** is necessary to generate a schema that allows information storage. To accomplish this, we provide a generator, however, if you want to manually generate WProf you need the following models (Migration files are exposed).
+
+> Modelo: WprofController
+``` ruby
+class CreateWprofControllers < ActiveRecord::Migration[5.0]
+  def change
+    create_table :wprof_controllers do |t|
+      t.string :transaction_id
+      t.float :total_time
+      t.datetime :start_dt
+      t.datetime :end_dt
+      t.integer :code
+      t.string :controller
+      t.string :url
+      t.float :db_runtime
+
+      t.timestamps
+    end
+    add_index :wprof_controllers, :transaction_id
+    add_index :wprof_controllers, :code
+    add_index :wprof_controllers, :url
+  end
+end
+```
+> Modelo: WprofService
+``` ruby
+class CreateWprofServices < ActiveRecord::Migration[5.0]
+  def change
+    create_table :wprof_services do |t|
+      t.string :transaction_id
+      t.float :total_time
+      t.datetime :start_dt
+      t.datetime :end_dt
+      t.integer :code
+      t.string :service_hostname
+      t.string :request_uri
+
+      t.timestamps
+    end
+    add_index :wprof_services, :transaction_id
+    add_index :wprof_services, :code
+    add_index :wprof_services, :service_hostname
+    add_index :wprof_services, :request_uri
+  end
+end
+```
+> Modelo: WprofMethod
+``` ruby
+class CreateWprofMethods < ActiveRecord::Migration[5.0]
+  def change
+    create_table :wprof_methods do |t|
+      t.string :transaction_id
+      t.float :total_time
+      t.datetime :start_dt
+      t.datetime :end_dt
+      t.string :method
+
+      t.timestamps
+    end
+    add_index :wprof_methods, :transaction_id
+    add_index :wprof_methods, :method
+  end
+end
+```
+
+### External Request Reporter.
+An option is sending data by HTTP wherever you want. Data obtained by Wprof will be sended in the body as JSON format. In order for this to work well it’s **necessary to configure destination’s URL**. Petition generated is POST and, when needed, you can configure the necessary HEADERS. If the URL is not configured, petition won’t be sended.
+The options to be set are: external_url and external_headers. See Configurations section for more information.
+
+---
+
+## Asynchronism.
+
+WProf by default reports all the information **synchronous**, although it’s possible to configure the tool in order to do this process **asynchronous**. To achieve this, you must first activate the option through config field "config.x.wprof.async = true", however this is not enough. For all of the report be made asynchronous, you must have functional and operational **Sidekiq**, since WProf uses it to that purpose. If you’re not familiar with the tool, you could give it a look to its [repository by clicking here!.](https://github.com/mperham/sidekiq).
+
+---
+
+## Handled errors.
+
+Any error among the capture and report of the information **MUSTN’T** interrupt the normal functioning of your Rails application. If this is the case, please report it. During the execution, could show up two errors in application’s logger.
+WProf ERROR when try parsing service response: 
+An error was raised when WProf tried to send data to reporter: This is the most common error and it will appear if the data sending to the selected destination (meaning Logger, Database, File o External) has failed.
+
+```WProf ERROR when try parsing service response:``` This error may appear if HTTParty wouldn’t be able to capture some data.
+
+```An error was raised when WProf tried to send data to reporter:``` This is the most common error and it will appear if the data sending to the selected destination (meaning Logger, Database, File o External) has failed.
+
+---

data/doc/user-guide_es.md

@@ -0,0 +1,297 @@
+# Wor-Prof
+
+Wor-prof (Wprof) es una gema para Ruby On Rails cuyo único objetivo es el medir el rendimiento de una aplicación RoR mediante un perfil de distintos tiempos de respuesta. Para lograrlo, Wprof utiliza ActiveSupport::Notifications (disponible en Rails desde la versión 4.0.2) para capturar toda acción de sus controladores. Pero no sólo eso, si usas httparty en tu proyecto también puedes capturar cada request realizada a servicios externos. Tienes uno o más métodos que también quisieras conocer cuánto se demoran en ejecutarse? Con Wprof puedes saberlo. Luego, cada dato obtenido puede reportarse de distintas formas, elige una entre el logger de Rails, base de datos, archivo de texto en formato CSV o bien realiza un request Post a donde quieras… hazlo de forma sincrónica o asíncrona.
+
+---
+
+## Comenzar.
+
+El primer paso es instalar la gema (por supuesto) y la forma es bien conocida, pero por si acaso acá están los pasos a seguir.
+
+### Installation
+Agregar la siguiente línea en el gemfile de tu aplicación Rails:
+
+```ruby
+gem 'wor-prof'
+```
+
+Y luego ejecute:
+```bash
+$ bundle install
+```
+**Eso es todo!!** Al correr el servidor Wprof comienza inmediatamente a trabajar con la configuración por defecto por lo que no hay que configurar nada si coincide con sus necesidades, pero si no es así puede consultar la sección de **Configuraciones Disponibles**.
+
+---
+
+## Tipos de registros y cómo funciona.
+
+Como tipo de registros WProf cuenta con los siguientes.
+
+* Controladores: Cada request realizada a Rails que es manejada por un *Controller*. (Esto viene por defecto y no puede desactivarse)
+* HTTParty: Cada vez que se invoca un método de HTTParty.
+* Métodos propios: Se puede definir un Array de Métodos a capturar.
+
+``Solamente "Controladores" son automáticamente perfilados con sólo agregar la gema, el resto necesita alguna configuración u operación extra.``
+
+### HTTparty
+HTTParty es una popular herramienta para Ruby que permite realizar fácilmente peticiones HTTP. Si no está familiarizado con la gema le recomiendo leer más sobre está en el repositorio de la misma, [aquí!](https://github.com/jnunemaker/httparty)
+
+Para poder perfilar las request que se hacen mediante HTTParty debe incluir Wprof justo después de Httparty. Es decir:
+```ruby
+class FooClass
+    include HTTParty
+    include Wprof
+```
+Qué significa esto? Wprof envuelve los métodos invocados como métodos de clase, espera la respuesta y captura algunos datos necesarios para generar el perfil. Es por esto que la inclusión del módulo debe ser **obligatoriamente** después de HTTParty... si esto no es así, sencillamente no funcionará.
+
+Por defecto, WProf define los métodos que comúnmente se utilizan para generar una petición (Get, Put, Delete, Post), sin embargo puede definir otros o bien quitar alguno de esos de la lista. Es **fuertemente recomendado** no **agregar** métodos de HTTParty sin estar completamente seguro que el retorno de estos coincide con lo que WProf buscará capturar (puede consultar la sección "Datos Capturados" para conocer cuales son).
+
+### Métodos propios
+
+Algunas veces puede resultar de utilidad conocer cuánto se demora un método específico en ejecutarse, para este fin Wor-prof puede extender una mano.
+
+Para lograrlo se necesitan seguir 2 pasos.
+
+1. Preparar un array de métodos que se desean trazar (consulte la sección de configuración: "custom_methods")
+2. Incluir Wprof a la clase que tiene dicho método.
+
+Listo, con esto Wprof estará registrando el tiempo de ejecución de dicho método cada vez que sea invocado y lo reportará.
+
+---
+
+## Configuraciones disponibles.
+
+Por defecto Wprof continúe una lista de configuraciones por defecto, pero todas estas pueden ser modificadas por otras disponibles de acuerdo a las preferencias del usuario. Para lograr esto se debe crear un archivo en 'config/initializers' (RailsApp.Root >> config >> initializers >> wprof.rb).
+Dentro del mismo se debe definir la configuración de esta manera: 
+
+```ruby
+Rails.application.configure do
+  config.x.wprof.db_runtime = true
+  config.x.wprof.reporter_type = 'FILE'
+end
+```
+> En caso de no configurar correctamente una opción u omitirla, se tomarán los valores por defecto.
+
+Para evitar esta configuración manualmente utilizando el **Generador de Configuración** con el comando "rails generate wprof" (consulte la sección de generadores).
+
+A continuación se ofrece la lista completa de configuraciones disponibles y sus significados.
+
+### config.x.wprof.db_runtime
+Define si se debe mostrar o no el dato "db_runtime" dentro del reporte.
+> Valores Posibles: true o false
+> Por defecto: true
+
+### config.x.wprof.reporter_type 
+Establece el tipo de reporte, es decir, como exponen los datos obtenidos, existen cuatro tipo disponible actualmente, Ver sección "Reportes" para más información.
+> Valores Posibles: LOGGER, FILE, DATABASE, EXTERNAL
+> Por defecto: LOGGER
+
+### config.x.wprof.csv_type
+Cuando se define el reporte como un archivo CSV existen dos formas de generarlos.
+* **MIX:** Genera un único archivo CSV donde se guardan los datos de **todo** lo que captura WProf. Este archivo solo tiene 2 columnas: En la primera se guarda el campo y en la segunda el dato.
+* **SPLIT:** Divide el almacenamiento en tres archivos distintos, uno por cada tipo de registro. Esto mejora significamente la lectura ya que cada campo está como encabezado del archivo y los datos en la filas separados por coma... como debe ser claro... ¿Por que mix entonces?, no sé, a alguno le puede servir!
+> Valores Posibles: MIX, SPLIT
+> Por defecto: SPLIT
+
+### config.x.wprof.async
+Define si el reporte se gestará de forma Sincrónica o Asincronica. **Tome nota: la forma asincrónica requiere pasos adicionales, consulte la sección de "Asincronismo" para más información**
+> Valores Posibles: false, true
+> Por defecto: false
+
+### config.x.wprof.httparty_methods_to_trace
+Métodos de HTTParty que WProf va a capturar. Por defecto se colocan los más comunes y se recomienda no modificar. Dicho esto, no hay problema en quitar algunos del array, pero tenga especial cuidado en agregar métodos de HTTParty que no devuelvan un request HTTP).
+> Valores Posibles: Los que quiera, debe si o si ser un **Array** de strings.
+> Por defecto: ['get', 'put', 'delete', 'post']
+
+### config.x.wprof.external_url
+En caso de que se configure el reporter_type como External, se debe indicar la URL a la que se enviará la petición HTTP.
+> Valores posibles: Cualquier cadena de texto que corresponda a una URL. Ejemplo: 'http://example-url/reporter'
+> Por defecto: nil
+
+### config.x.wprof.external_headers
+Para agregar una cabecera al request HTTP (para el tipo de reporte "External"), debe definirlo en esta configuración. La misma debe ser un **HASH de RUBY** tal cual como espera HTTParty recibir (internamente Wprof utiliza HTTParty para enviar el request). Un ejemplo de esto sería:
+``` ruby
+config.x.wprof.external_headers = { headers: {'User-Agent' => 'Httparty'}}
+```
+> Valores posibles: Cualquier hash válido, debe respetarse la primera clave como "headers" (ver ejemplo arriba)
+> Por defecto: nil
+
+### config.x.wprof.custom_methods
+Si desea capturar los tiempos de respuesta de un método específico dentro de una clase, no basta con incluir el módulo, debe indicarle a Wprof cual es exactamente aquel que desea capturar. Esta lista de métodos debe estar contenida en está opción dentro de un **Array de Ruby** y deben ser strings. Ejemplo:
+``` ruby
+config.x.wprof.custom_methods = [ 'my_great_method' ]
+```
+> Valores posibles: Cualquier nombre de método en formato string, contenido en un array.
+> Por defecto: nil
+
+### config.x.wprof.file_path
+
+Cuando se utiliza "FILE" como salida de datos, esta opción permite elegir la ruta de destino de los archivos. Esta debe ser una ruta válida, en formato string, con permisos de escritura para la aplicación Rails y cuyo último valor debe ser una carpeta. Ejemplo: 
+``` ruby
+config.x.wprof.file_path = '/home/mcolombo/examplefolder'
+```
+> Valores posible: Cualquier string que represente correctamente un PATH hasta un directorio.
+> Por defecto: Se utiliza 'Rails.root', es decir, la raíz de su aplicación Rails.
+
+---
+
+## Generadores.
+
+WProf tiene disponible dos [generadores de Rails](https://guides.rubyonrails.org/command_line.html#rails-generate) disponibles.
+
+---
+
+### Generador del archivo de Configuración.
+
+Para comenzar a modificar las opciones de configuración disponibles, debe crear un archivo de configuración dentro de los 'config/initializers' (como se mencionó en la sección "Configuraciones disponibles"). A favor de evitar pasos innecesarios y posibles equivocaciones en los peligrosos 'copy/paste', puede generar este archivo como un template con el siguiente comando Rails:
+
+```
+rails generate wprof
+```
+Esto  generará un modelo del archivo de configuración, con todas las opciones disponibles vistas en la sección "Configuraciones disponibles".
+
+### Generador del modelo de datos
+
+Una opción disponible para reportar la información capturada es la misma Base de Datos que utiliza Rails, pero el problema de esto es que se requiere justamente definir el modelo. Este generador creará todos los archivos de migración y los modelos para poder utilizar esta opción sin preocuparse por nada más.
+```
+rails generate wprof_model
+```
+Esto generará los archivos de migración y los modelos (incluso los controladores por si desea manejarlos!)
+**Recuerde que para que los modelos se encuentren disponibles en la base aún debe correr la migración**
+```
+rails db:migrate
+```
+
+---
+
+## Datos capturados.
+
+Los datos que captura y reporta WProf varían de acuerdo a que tipo de registro proviene, sin embargo, todos comparten algunos datos base.
+
+### Datos base (comunes para todos)
+
+* **transaction_id:** identificador único de cada transacción. Este campo es de vital importancia debido a que los registros de HTTParty y Métodos comparten este mismo identificador con el Request que disparó esta ejecución permitiendo una traza completa de la ejecución de cada uno.
+* **total_time:** Tiempo total de ejecución registrado (en milisegundos).
+* **start_dt:** Campo de Fecha y Hora en que comenzó a registrarse.
+* **end_dt:** Campo de Fecha y Hora en que finalizó el registro.
+
+### Únicos para el Controlador.
+
+* **code:** Código de respuesta enviado por el controlador (Status), ej. 200, 404, etc.
+* **controller:** Controlador que manejó el request.
+* **url:** endpoint que recibió la solicitud.
+* **db_runtime:** Tiempo total que fue absorbido por la Base de Datos (incluido en el total_time).
+
+### Únicos para los Servicios (Httparty).
+
+* **code:** Código de respuesta recibido (Status), ej. 200, 404, etc.
+* **service_hostname:** Hostname del servicio consumido.
+* **request_uri:** Uri del endpoint consumido.
+
+### Únicos para los métodos.
+
+* **method:** Nombre del método que fue medido.
+
+---
+
+## Reportes.
+
+El destino de los datos, una vez que son capturados y procesados, varía de acuerdo a las preferencias del usuario. Wor-Prof ofrece los siguientes destinos para la información:
+* **LOGGER:** Utiliza Rails.logger para mostrar la información.
+* **FILE:** Guarda la información en uno ó varios archivos de texto separados por coma (csv)
+* **DATABASE:** Almacena los datos obtenidos en la misma base de datos que utiliza la aplicación Rails (requiere preparar el modelo, ver generadores/generador del modelo de datos)
+* **EXTERNAL:** Realiza una petición POST con los datos enviados en el cuerpo en formato JSON. (requiere configuración adicional)
+
+> Tanto "Logger" como "File" no necesitan configuración adicional para trabajar, sin embargo "Database" y "External" requieren pasos previos.
+
+### Database Reporter
+
+Para **DATABASE** es necesario generar un esquema que permita almacenar la información. Para lograr esto ponemos a disposición un generador, sin embargo, si se desea generar manualmente WProf necesita los siguientes modelos (se exponen los archivos de Migración).
+
+> Modelo: WprofController
+``` ruby
+class CreateWprofControllers < ActiveRecord::Migration[5.0]
+  def change
+    create_table :wprof_controllers do |t|
+      t.string :transaction_id
+      t.float :total_time
+      t.datetime :start_dt
+      t.datetime :end_dt
+      t.integer :code
+      t.string :controller
+      t.string :url
+      t.float :db_runtime
+
+      t.timestamps
+    end
+    add_index :wprof_controllers, :transaction_id
+    add_index :wprof_controllers, :code
+    add_index :wprof_controllers, :url
+  end
+end
+```
+> Modelo: WprofService
+``` ruby
+class CreateWprofServices < ActiveRecord::Migration[5.0]
+  def change
+    create_table :wprof_services do |t|
+      t.string :transaction_id
+      t.float :total_time
+      t.datetime :start_dt
+      t.datetime :end_dt
+      t.integer :code
+      t.string :service_hostname
+      t.string :request_uri
+
+      t.timestamps
+    end
+    add_index :wprof_services, :transaction_id
+    add_index :wprof_services, :code
+    add_index :wprof_services, :service_hostname
+    add_index :wprof_services, :request_uri
+  end
+end
+```
+> Modelo: WprofMethod
+``` ruby
+class CreateWprofMethods < ActiveRecord::Migration[5.0]
+  def change
+    create_table :wprof_methods do |t|
+      t.string :transaction_id
+      t.float :total_time
+      t.datetime :start_dt
+      t.datetime :end_dt
+      t.string :method
+
+      t.timestamps
+    end
+    add_index :wprof_methods, :transaction_id
+    add_index :wprof_methods, :method
+  end
+end
+```
+
+### External Request Reporter.
+Una opción es enviar los datos por HTTP donde desee. Los datos obtenidos por Wprof serán enviados en el cuerpo como un JSON. Para que esto funcione bien es **necesario configurar la URL de destino**. La petición que se genera es POST y de ser necesario puede **configurar los HEADERS necesarios**. Si la URL no se configura, la petición no será enviada.
+
+Las opciones a configurar son: external_url y external_headers. Consulte la sección de Configuraciones para más información.
+
+---
+
+## Asincronismo.
+
+WProf por defecto reporta toda la información de manera ***sincronica**, sin embargo es posible configurar la herramienta para que este proceso lo haga de forma **asincronica**. Para lograr esto se debe en primer lugar activar la opción mediante la configuración del campo "config.x.wprof.async = true", sin embargo esto no es suficiente.
+Para que todo el reporte se efectúe Asincrónicamente, es necesario tener funcional y operativo **Sidekiq**, ya que WProf lo utiliza para tal fin. Si no está familiarizado con la herramienta, puede buscar más información en el [repositorio de la misma haciendo click aquí!](https://github.com/mperham/sidekiq).
+
+---
+
+## Errores manejados.
+
+Cualquier error dentro del proceso de captura y reporte de la información **NO DEBERIA** interrumpir el normal funcionamiento de su aplicación Rails. Si esto es así, por favor **reportelo**.
+Durante la ejecución, podrían aparecer dos errores en el Logger de la aplicación.
+
+```WProf ERROR when try parsing service response:``` Este error puede mostrarse si no fue posible capturar algún dato por parte de HTTParty.
+
+```An error was raised when WProf tried to send data to reporter:``` Este es el error más típico y se mostrará en caso de que el envío de datos al destino seleccionado (es decir Logger, Database, File o External) haya fallado.
+
+---

data/lib/generators/wprof_generator.rb

@@ -0,0 +1,42 @@
+class WprofGenerator < Rails::Generators::Base
+  desc 'This generator creates an initializer file for Wor-Prof!'
+  def wor_prof_init
+    create_file 'config/initializers/wprof.rb', init_wprof
+  end
+
+  private
+
+  def init_wprof
+    <<~CONTENT
+    # -----------------------------------------
+    # Uncomment and set for use custom options.
+    # -----------------------------------------
+    Rails.application.configure do
+    ## Save DB Runtime?: Default: true 
+    # config.x.wprof.db_runtime = true
+    ## Reporter Type (¿When we will save our data?): 'LOGGER' by default.
+    ## Another options: 'FILE' (For CSV), 'DATABASE' (For Rails DB), 'EXTERNAL' (For external API).
+    # config.x.wprof.reporter_type = 'LOGGER'
+    ## CSV Type (One CSV file for each type of data or all together)
+    ## 'SPLIT' by default, Options: 'MIX'
+    # config.x.wprof.csv_type = 'SPLIT' 
+    ## Reporter must be work async? Default: false
+    # config.x.wprof.async = false
+    ## Httparty Methods to wrapper.
+    # config.x.wprof.httparty_methods_to_trace = ['get', 'put', 'delete', 'post']
+    ## External URL for hit when Reporter Type is EXTERNAL
+    ## DEFAULT: nil
+    # config.x.wprof.external_url = 'http://example-url/reporter'
+    ## Define Headers for Reporter Type when is EXTERNAL.
+    ## Must be a Hash (see HTTPARTY doc for more info)
+    ## DEFAULT: nil
+    # config.x.wprof.external_headers = { headers: {'User-Agent' => 'Httparty'}}
+    ## Define your Custom Methods here! (Must be an Array)
+    # config.x.wprof.custom_methods = [ 'my_great_method' ]
+    ## Define your own path for save Files when Reporter Type is FILE
+    ## By default Wor-Prof use Rails.root
+    # config.x.wprof.file_path = '/home/mcolombo/examplefolder'
+    end
+    CONTENT
+  end
+end

data/lib/generators/wprof_model_generator.rb

@@ -0,0 +1,14 @@
+class WprofModelGenerator < Rails::Generators::Base
+  desc 'This generator creates all model for use Wor-prof witch reporter_type as Database'
+  def wprof_migrations
+    making_wprof_migrations
+  end
+
+  private
+
+  def making_wprof_migrations
+    generate 'model', 'WprofController transaction_id:string:index total_time:float start_dt:datetime end_dt:datetime code:integer:index controller:string url:string:index db_runtime:float'
+    generate 'model', 'WprofService transaction_id:string:index total_time:float start_dt:datetime end_dt:datetime code:integer:index service_hostname:string:index request_uri:string:index'
+    generate 'model', 'WprofMethod transaction_id:string:index total_time:float start_dt:datetime end_dt:datetime method:string:index'
+  end
+end