putsreq 0.0.3 → 0.0.4

data/app/interactors/create_or_retrieve_bucket.rb

@@ -0,0 +1,17 @@
+class CreateOrRetrieveBucket
+  include Interactor
+
+  delegate :token, :owner_token, :user_id, to: :context
+
+  def call
+    if (bucket = Bucket.where(token: token).first)
+      return context.bucket = bucket
+    end
+
+    context.bucket = Bucket.create(
+      owner_token: owner_token,
+      user_id: user_id,
+      token: token
+    )
+  end
+end

data/app/interactors/create_request.rb

@@ -4,12 +4,30 @@ class CreateRequest
   delegate :bucket, :rack_request, to: :context
 
   def call
-    context.request = bucket.requests.create(body:            rack_request.body.read,
-                                             content_length:  rack_request.content_length,
-                                             request_method:  rack_request.request_method,
-                                             ip:              rack_request.ip,
-                                             url:             rack_request.url,
-                                             headers:         FilterHeaders.call(headers: rack_request.env).headers,
-                                             params:          rack_request.request_parameters)
+    context.request = bucket.requests.create(
+      body: body(rack_request),
+      content_length: rack_request.content_length,
+      request_method: rack_request.request_method,
+      ip: rack_request.ip,
+      url: rack_request.url,
+      headers: FilterHeaders.call(headers: rack_request.env).headers
+    )
+
+    context.params = params
+  rescue
+    Rollbar.scope!(request: context.request)
+    raise
+  end
+
+  private
+
+  def params
+    rack_request.params.to_h.except('controller', 'action', 'token')
+  end
+
+  def body(rack_request)
+    body = rack_request.body.read.encode('UTF-8', invalid: :replace, undef: :replace)
+
+    body.is_utf8? ? body : nil
   end
 end

data/app/interactors/eval_response_builder.rb

@@ -1,7 +1,7 @@
 class EvalResponseBuilder
   include Interactor
 
-  delegate :request, to: :context
+  delegate :request, :params, to: :context
 
   def call
     v8_ctx = V8::Context.new timeout: timeout
@@ -12,9 +12,9 @@ class EvalResponseBuilder
 
     eval_response(v8_ctx)
   rescue => e
-    context.built_response = { 'status'  => 500,
+    context.built_response = { 'status' => 500,
                                'headers' => { 'Content-Type' => 'text/plain' },
-                               'body'    => e.message }
+                               'body' => e.message }
   end
 
   private
@@ -28,19 +28,19 @@ class EvalResponseBuilder
 
     # filter allowed parameters
     context.built_response = JSON.parse(context.built_response).select do |key, value|
-      %w(status headers body).include?(key) && value.to_s.present?
+      %w[status headers body].include?(key) && value.to_s.present?
     end
   end
 
   def initialize_response_builder_attrs(v8_ctx)
-    v8_ctx['response'] = { 'status'  => 200,
+    v8_ctx['response'] = { 'status' => 200,
                            'headers' => {},
-                           'body'    => 'ok' }
+                           'body' => 'ok' }
 
     v8_ctx['request']  = { 'request_method' => request.request_method,
-                           'body'           => request.body,
-                           'params'         => request.params,
-                           'headers'        => request.headers }
+                           'body' => request.body,
+                           'params' => params,
+                           'headers' => request.headers }
   end
 
   def eval_response_builder(v8_ctx)

data/app/interactors/filter_headers.rb

@@ -1,8 +1,8 @@
 class FilterHeaders
   include Interactor
 
-  BLACKLIST_HEADERS = %w(HOST CF X-REQUEST X-FORWARDED CONNECT-TIME TOTAL-ROUTE-TIME VIA).freeze
-  WHITELIST_HEADERS = %w(HTTP_ CONTENT).freeze
+  BLACKLIST_HEADERS = %w[HOST CF X-REQUEST X-FORWARDED CONNECT-TIME TOTAL-ROUTE-TIME VIA].freeze
+  WHITELIST_HEADERS = %w[HTTP_ CONTENT].freeze
 
   delegate :headers, to: :context
 
@@ -14,7 +14,7 @@ class FilterHeaders
 
   def client_supplied_headers
     headers.to_h.each_with_object({}) do |(key, value), h|
-      next unless value.to_s.present?
+      next if value.to_s.blank?
 
       next unless key.upcase.start_with?(*WHITELIST_HEADERS)
 

data/app/interactors/forward_request.rb

@@ -9,9 +9,9 @@ class ForwardRequest
     # use the response from the forwarded URL
     context.built_response = forward_to(built_request, forward_url)
   rescue => e
-    context.built_response = { 'status'  => 500,
+    context.built_response = { 'status' => 500,
                                'headers' => { 'Content-Type' => 'text/plain' },
-                               'body'    => e.message }
+                               'body' => e.message }
   end
 
   private
@@ -23,9 +23,9 @@ class ForwardRequest
 
     forwarded_response = HTTParty.send(built_request['request_method'].downcase.to_sym, forward_url, options)
 
-    { 'status'  => forwarded_response.code,
+    { 'status' => forwarded_response.code,
       'headers' => FilterHeaders.call(headers: forwarded_response.headers).headers,
-      'body'    => forwarded_response.body }
+      'body' => forwarded_response.body }
   end
 
   def body

data/app/interactors/record_request.rb

@@ -1,5 +1,5 @@
 class RecordRequest
   include Interactor::Organizer
 
-  organize CreateRequest, EvalResponseBuilder, ForwardRequest, CreateResponse, NotifyCount
+  organize CreateRequest, EvalResponseBuilder, ForwardRequest, CreateResponse, Track
 end

data/app/interactors/track.rb

@@ -0,0 +1,44 @@
+class Track
+  include Interactor
+
+  delegate :bucket, :rack_request, to: :context
+  delegate :token, to: :bucket
+  delegate :ip, :user_agent, to: :rack_request
+
+  def call
+    return unless enabled?
+
+    tracker.event(category: 'bucket', action: 'record', label: token, value: 1) # , non_interactive: true)
+  rescue => e
+    Rollbar.error(e, token: token)
+  end
+
+  private
+
+  def global_context
+    {
+      user_ip: ip,
+      ssl: true,
+      user_agent: user_agent
+    }
+  end
+
+  def client_id
+    # since there's no identification in the requests,
+    # the only way to aggregate requests per "user" is per ip
+    # https://stackoverflow.com/a/31854739/464685
+    ip
+  end
+
+  def enabled?
+    google_analytics_tracking_id.present?
+  end
+
+  def google_analytics_tracking_id
+    ENV['GOOGLE_ANALYTICS_TRACKING_ID']
+  end
+
+  def tracker
+    @_tracker ||= Staccato.tracker(google_analytics_tracking_id, client_id, global_context)
+  end
+end

data/app/javascript/actionTypes.js

@@ -0,0 +1,7 @@
+const bucketsActions = {
+  populate: 'POPULATE',
+  loading: 'LOADING',
+  updateRequestsCount: 'UPDATE_REQUESTS_COUNT'
+}
+
+export { bucketsActions }

data/app/javascript/actions/index.js

@@ -0,0 +1,64 @@
+import fetch from 'cross-fetch'
+import { bucketsActions } from '../actionTypes'
+
+const getJSONFromPage = id => JSON.parse(document.getElementById(id).innerText)
+
+const fetchFromPage = () => {
+  const bucket = getJSONFromPage('bucket-json')
+  favicon.badge(bucket.requests_count)
+
+  return {
+    type: bucketsActions.populate,
+    bucket,
+    page: 1
+  }
+}
+
+const favicon = new Favico({ bgColor: '#6C92C8', animation: 'none' })
+
+const updateRequestsCount = count => {
+  return (dispatch, getState) => {
+    if (count === getState().bucket.requests_count) {
+      return
+    }
+
+    favicon.badge(count)
+
+    let page = getState().bucket.page || 1
+
+    if (count > getState().bucket.request_count) {
+      page = count - getState().bucket.requests_count + page
+    }
+
+    dispatch({
+      type: bucketsActions.updateRequestsCount,
+      requests_count: count,
+      page: page
+    })
+
+    if (count === 1) {
+      return fetchPage(1)(dispatch, getState)
+    }
+  }
+}
+
+const handlePageChange = page => {
+  return (dispatch, getState) => {
+    dispatch({ type: bucketsActions.loading })
+
+    fetchPage(page)(dispatch, getState)
+  }
+}
+
+const fetchPage = page => {
+  return (dispatch, getState) => {
+    fetch(`${getState().bucket.path}.json?page=${page}`)
+      .then(
+        response => response.json(),
+        error => console.log('An error occurred.', error)
+      )
+      .then(bucket => dispatch({ type: bucketsActions.populate, bucket, page }))
+  }
+}
+
+export { fetchFromPage, handlePageChange, updateRequestsCount }

data/app/javascript/components/Bucket.jsx

@@ -0,0 +1,91 @@
+import React, { Component } from 'react'
+import { connect } from 'react-redux'
+import Request from './request'
+import Pagination from './Pagination'
+import { fetchFromPage, handlePageChange } from '../actions'
+import PropTypes from 'prop-types'
+
+class Bucket extends Component {
+  componentWillMount() {
+    this.props.fetchFromPage()
+  }
+
+  renderFirstRequestLink() {
+    if(!this.props.bucket.request) { return }
+
+    return (
+      <em>Request ID: <a href={this.props.bucket.request.path} target="_blank">{this.props.bucket.request.id}</a></em>
+    )
+  }
+
+  renderFirstRequest() {
+    if(!this.props.bucket.first_request) { return }
+
+    return (
+      <p>
+        <em>First request at: {this.props.bucket.first_request.created_at}</em> <br />
+        <em>Last request at: {this.props.bucket.last_request.created_at}</em> <br />
+
+        {this.renderFirstRequestLink()}
+      </p>
+    )
+  }
+
+  handlePageChange(page) {
+    this.props.handlePageChange(page)
+  }
+
+  renderPagination() {
+    if(!this.props.bucket.request) { return }
+
+    return (
+      <Pagination
+          pageCount={this.props.bucket.requests_count}
+          page={this.props.bucket.page}
+          onPageChange={this.handlePageChange.bind(this)}
+      />
+    )
+  }
+
+  renderRequestOrLoading() {
+    if(this.props.bucket.loading) {
+      return (
+        <div><em><strong>Loading...</strong></em></div>
+      )
+    }
+
+    return (<Request {...this.props.bucket.request} />)
+  }
+
+  render() {
+    if(!this.props.bucket) { return }
+
+    return (
+      <div>
+        <div className="row">
+          <div className="col-md-6">
+            {this.renderFirstRequest()}
+          </div>
+          <div className="col-md-6"></div>
+        </div>
+        {this.renderPagination()}
+        {this.renderRequestOrLoading()}
+      </div>
+    )
+  }
+}
+
+Bucket.propTypes = {
+  bucket: PropTypes.object.isRequired
+}
+
+const mapStateToProps = (state) => ({
+  bucket: state.bucket
+})
+
+const mapDispatchToProps = {
+  handlePageChange: handlePageChange,
+  fetchFromPage: fetchFromPage
+}
+
+export default connect(mapStateToProps, mapDispatchToProps)(Bucket)

data/app/javascript/components/Pagination.jsx

@@ -0,0 +1,67 @@
+import React, { Component } from 'react'
+import PropTypes from 'prop-types'
+
+export default class Pagination extends Component {
+  handleFirstPage() {
+    this.props.onPageChange(1)
+  }
+
+  handlePreviousPage() {
+    const previousPage = this.props.page - 1
+    if(previousPage > 0) { this.props.onPageChange(previousPage) }
+  }
+
+  handleNextPage() {
+    const nextPage = this.props.page + 1
+    if(nextPage <= this.props.pageCount) { this.props.onPageChange(nextPage) }
+  }
+
+  handleLastPage() {
+    this.props.onPageChange(this.props.pageCount)
+  }
+
+  firstClassNames() {
+    if(this.props.page <= 1) { return 'disabled' }
+  }
+
+  previousClassNames() {
+    const previousPage = this.props.page - 1
+
+    if(previousPage <= 0) { return 'disabled' }
+  }
+
+  nextClassNames() {
+    const nextPage = this.props.page + 1
+
+    if(nextPage > this.props.pageCount) { return 'disabled' }
+  }
+
+  lastClassNames() {
+    if(this.props.page >= this.props.pageCount) { return 'disabled' }
+  }
+
+  render() {
+    return(
+      <ul className="pagination">
+        <li className={this.firstClassNames()}>
+          <a onClick={this.handleFirstPage.bind(this)}>First</a>
+        </li>
+        <li className={this.previousClassNames()}>
+          <a onClick={this.handlePreviousPage.bind(this)}>Previous</a>
+        </li>
+        <li className={this.nextClassNames()}>
+          <a onClick={this.handleNextPage.bind(this)}>Next</a>
+        </li>
+        <li className={this.lastClassNames()}>
+          <a onClick={this.handleLastPage.bind(this)}>Last</a>
+        </li>
+      </ul>
+    )
+  }
+}
+
+Pagination.propTypes = {
+  page: PropTypes.number.isRequired,
+  pageCount: PropTypes.number.isRequired,
+  onPageChange: PropTypes.func.isRequired
+}

data/app/javascript/components/RequestCount.jsx

@@ -0,0 +1,21 @@
+import React, { Component } from 'react'
+import { connect } from 'react-redux'
+import PropTypes from 'prop-types'
+
+class RequestCount extends Component {
+  render() {
+    return (
+      <h3>{this.props.requests_count || 0}</h3>
+    )
+  }
+}
+
+RequestCount.propTypes = {
+  requests_count: PropTypes.number
+}
+
+const mapStateToProps = (state) => ({
+  requests_count: state.bucket.requests_count
+})
+
+export default connect(mapStateToProps)(RequestCount)