speakeasy_ruby_sdk 0.0.2

data/lib/speakeasy_ruby_sdk/har_builder.rb

@@ -0,0 +1,242 @@
+module SpeakeasyRubySdk
+  class HarBuilder
+
+    def initialize api_config
+      @api_config = api_config
+    end
+
+    def construct_creator name, version
+      return {
+        "name": name,
+        "version": version
+      }
+    end
+
+    def construct_log version, creator, entries, comment
+      return {
+        'log': {
+          "version": version,
+          "creator": creator,
+          "entries": entries,
+          "comment": comment
+        }
+      }
+    end
+
+
+    def construct_empty_cache
+      return {
+      }
+    end
+    def construct_empty_params
+      return []
+    end
+
+    def construct_query_records query_params
+      query_params.map {|k, v| {
+        "name": k,
+        "value": v
+      } }.sort_by(&lambda{ |h| h[:name] })
+    end
+
+    def construct_response_cookies cookies
+      final_cookies = []
+      if ! cookies.nil?
+        for cookie in cookies
+          new_cookie = {
+            'name': cookie.name, 
+            'value': cookie.value,
+          }
+          if cookie.path && cookie.path != '/'
+            new_cookie['path'] = cookie.path
+          end
+          if cookie.domain
+            new_cookie['domain'] = cookie.domain
+          end
+          if cookie.expires
+            new_cookie['expires'] = cookie.expires.strftime("%Y-%m-%dT%H:%M:%S.%NZ")
+          end
+          if cookie.httponly
+            new_cookie['httpOnly'] = cookie.httponly
+          end
+          if cookie.secure
+            new_cookie['secure'] = cookie.secure
+          end
+          final_cookies << new_cookie
+        end
+      end
+      return final_cookies.sort_by(&lambda{ |c| c[:name] })
+    end
+
+    def construct_request_cookies cookies
+      if cookies.nil?
+        return []
+      else
+        return cookies.map{ |cookie|
+          {
+            'name': cookie[0],
+            'value': cookie[1]
+          }
+        }.sort_by(&lambda{ |c| c[:name] })
+      end
+    end
+
+    def construct_header_records headers
+      final_headers = []
+      for k, v in headers
+        if v.is_a? Array
+          for value in v
+            final_headers << {
+              "name": k,
+              "value": value
+            }
+          end
+        else
+          final_headers << {
+            "name": k,
+            "value": v
+          }
+        end
+      end
+      final_headers.sort_by(&lambda{ |h| h[:name] })
+    end
+
+    def construct_post_data request
+      content_type = request.headers['content-type']
+      if content_type.nil? || content_type.length == 0
+        content_type = "application/octet-stream"
+      end
+      if request.body.empty?
+        return nil
+      elsif (request.headers.include?('content-length')) && (!request.headers['content-length'].nil?) && (request.headers['content-length'].to_i > @api_config.max_capture_size)
+        return {
+          "mimeType": content_type,
+          "text": "--dropped--"
+        }
+      else
+        return {
+          "mimeType": content_type,
+          "text": request.body
+        }
+      end
+    end
+
+    def construct_response_content status, body, headers
+      content_type = headers['content-type']
+      if content_type.nil? || content_type.length == 0
+        content_type = "application/octet-stream"
+      end
+      if status == 304
+        return {
+          "mimeType": content_type,
+          "size": -1
+        }
+      elsif (headers.include?('content-length')) && (!headers['content-length'].nil?) && (headers['content-length'].to_i > @api_config.max_capture_size)
+        return {
+          "mimeType": content_type,
+          "text": "--dropped--",
+          "size": -1
+        }
+      elsif ! headers.include?('content-length')
+        return {
+          "mimeType": content_type,
+          "size": -1
+        }
+      else
+        return {
+          "mimeType": content_type,
+          "text": body,
+          "size": headers['content-length'].to_i
+        }
+      end
+    end
+
+    def calculate_header_size headers
+      raw_headers = ''
+      for k, v in headers
+        if v.is_a? Array
+          for value in v
+            raw_headers += "#{k}: #{value}\r\n"
+          end
+        else
+          raw_headers += "#{k}: #{v}\r\n"
+        end
+      end
+      raw_headers.bytesize
+    end
+
+    def construct_request request
+      req = {
+        "method": request.method,
+        "url": request.url,
+        "httpVersion": request.transaction.protocol,
+        "cookies": self.construct_request_cookies(request.cookies),
+        "headers": self.construct_header_records(request.headers),
+        "queryString": self.construct_query_records(request.query_params),
+        "headersSize": self.calculate_header_size(request.headers),
+        "bodySize": request.content_length.to_i,
+      }
+      if ! self.construct_post_data(request).nil?
+        req["postData"] = self.construct_post_data(request)
+      end
+      req
+    end
+
+    def construct_response response
+      res = {
+        "status": response.status,
+        "statusText":  Rack::Utils::HTTP_STATUS_CODES[response.status],
+        "httpVersion":  response.transaction.protocol,
+        "cookies":  self.construct_response_cookies(response.cookies),
+        "headers":  self.construct_header_records(response.headers),
+        "content":  self.construct_response_content(response.status, response.body, response.headers),
+        "redirectURL":  response.headers.fetch('location', ''),
+        "headersSize": self.calculate_header_size(response.headers)
+      }
+
+      if response.status == 304
+        res["bodySize"] = 0
+      elsif !response.headers.include?('content-length')
+        res["bodySize"] = -1
+      else
+        res["bodySize"] = response.body.bytesize
+      end
+      res
+    end
+
+    def construct_timings
+      return {
+        "send": -1,
+        "wait": -1,
+        "receive": -1,
+      }
+    end
+    
+    def construct_entries http_transaction
+      entry = {
+        "startedDateTime": http_transaction.time_utils.start_time.strftime("%Y-%m-%dT%H:%M:%S.%NZ"),
+        "time": http_transaction.time_utils.elapsed_time,
+        "request": self.construct_request(http_transaction.request),
+        "response": self.construct_response(http_transaction.response),
+        "serverIPAddress": http_transaction.request.url.hostname,
+        "cache": self.construct_empty_cache,
+        "timings": self.construct_timings
+      }
+      if !http_transaction.port.nil? && http_transaction.port != "80"
+        entry["connection"] = http_transaction.port
+      end
+      return [entry]
+    end
+
+    def construct_har http_transaction
+      creator = construct_creator SpeakeasyRubySdk.to_s, SpeakeasyRubySdk::VERSION
+      version = "1.2"
+      comment = "request capture for #{http_transaction.request.url.to_s}"
+
+      entries = construct_entries http_transaction
+
+      log = construct_log version, creator, entries, comment
+      log.to_json
+    end
+  end
+end

data/lib/speakeasy_ruby_sdk/http_transaction.rb

@@ -0,0 +1,122 @@
+require 'http-cookie'
+
+module SpeakeasyRubySdk
+  class HttpTransaction
+
+    attr_reader :time_utils, :status, :env, :request, :response, :protocol, :port
+    
+    def handle_forward_headers request_headers
+      if request_headers.include? 'x-forwarded-proto' && request_headers['x-forwarded-proto']
+        scheme = request_headers['x-forwarded-proto'].downcase
+      elsif request_headers.include? 'x-forwarded-scheme' && request_headers['x-forwarded-scheme']
+        scheme = request_headers['x-forwarded-scheme'].downcase
+      elsif request_headers.include? 'forwarded' && request_headers['forwarded']
+        forwarded = request_headers['forwarded']
+        protoRegex = Regexp.new(/(?i)(?:proto=)(https|http)/)
+        matches = forwarded.match(protoRegexp)
+        if matches.length > 1
+          scheme = matches[1].downcase
+        end
+      end
+      scheme
+    end
+
+    def initialize time_utils, env, status, response_headers, response_body, masker
+      ## Setup Data
+      @time_utils = time_utils
+      @status = status
+      @env = env
+      @protocol = env['SERVER_PROTOCOL']
+      @port = env['SERVER_PORT']
+
+      if ! response_body.nil? && response_body.respond_to?(:body)
+        response_body = response_body.body
+      elsif !response_body.nil? && response_body.respond_to?(:join)
+        response_body = response_body.join
+      elsif response_body.nil?
+        response_body = ''
+      end
+      # normalize request headers
+      request_headers = Hash[*env.select {|k,v| k.start_with? 'HTTP_'}
+        .collect {|k,v| [k.sub(/^HTTP_/, ''), v]}
+        .collect {|k,v| [k.split('_').collect(&:downcase).join('-'), v]}
+        .sort
+        .flatten]
+      request_body = env['rack.input'].read
+      request_method = env['REQUEST_METHOD']
+      rack_request = Rack::Request.new(env)
+      response_headers = Hash[response_headers.collect {|k,v| [k.downcase, v] }]
+      scheme = self.handle_forward_headers request_headers
+      if scheme
+        @protocol = scheme
+      end
+      query_params = Rack::Utils.parse_nested_query(env['QUERY_STRING'])
+
+      ## Temporary url var for populating cookiejar.
+      unmasked_url = UrlUtils.resolve_url env
+
+      request_cookies = CGI::Cookie.parse(request_headers['cookie'] || '').map { |cookie| [cookie[0], cookie[1][0]] }
+      response_cookies = HTTP::CookieJar.new()
+      if response_headers.include? 'set-cookie'
+        cookies = response_headers['set-cookie']
+        cookies.map { |cookie| response_cookies.parse(cookie, unmasked_url) }
+      end
+
+      ## Begin Masking
+      masked_query_params = masker.mask_query_params unmasked_url.path, query_params
+      
+      masked_request_headers = masker.mask_request_headers unmasked_url.path, request_headers
+      masked_response_headers = masker.mask_response_headers unmasked_url.path, response_headers
+
+      request_url = UrlUtils.resolve_url env, masked_query_params
+
+      masked_request_cookies = masker.mask_request_cookies unmasked_url.path, request_cookies
+      masked_response_cookies = masker.mask_response_cookies unmasked_url.path, response_cookies
+
+      masked_request_body = masker.mask_request_body unmasked_url.path, request_body
+      masked_response_body = masker.mask_response_body unmasked_url.path, response_body
+
+
+      ## Construct Request Response
+      @request = HttpRequest.new self, rack_request, request_url, request_method, masked_request_headers, masked_query_params, masked_request_body, masked_request_cookies
+      @response = HttpResponse.new self, status, masked_response_headers, masked_response_body, masked_response_cookies
+    end
+  end
+
+  class HttpRequest
+    attr_reader :transaction, :method, :url, :query_params, :headers, :body, :cookies
+    def initialize transaction, rack_request, request_url, request_method, request_headers, query_params, request_body, request_cookies
+      @transaction = transaction
+      @rack_request = rack_request
+      @url = request_url
+      @query_params = query_params
+      @method = request_method
+      @headers = request_headers
+      @body = request_body
+      @cookies = request_cookies
+    end
+
+    def content_type
+      @rack_request.content_type
+    end
+
+    def content_length
+      if @rack_request.content_length == "0"
+        -1
+      else
+        @rack_request.content_length
+      end
+    end
+  end
+
+  class HttpResponse
+    attr_reader :transaction, :status, :headers, :body, :cookies
+    def initialize transaction, status, response_headers, response_body, response_cookies
+      @transaction = transaction
+      @status = (status.nil? || status == -1) ? 200 : status
+      @headers = response_headers
+      @body = response_body
+      @cookies = response_cookies
+    end
+  end
+end

data/lib/speakeasy_ruby_sdk/masker.rb

@@ -0,0 +1,166 @@
+module SpeakeasyRubySdk
+
+  class MaskConfig
+    attr_reader :type, :attributes, :masks, :controller
+    def initialize type, attributes, masks=nil, controller=nil
+      @type = type
+      @contoller = controller
+      @attributes = attributes
+      @masks = masks
+    end
+
+    def get_mask_for_attribute attribute
+      if @masks.nil? || @masks.empty?
+        SpeakeasyRubySdk::Masker::SIMPLE_MASK
+      elsif @masks.length == 1
+        @masks[0]
+      else
+        i = @attributes.find_index{|att| att == attribute}
+        if i > @masks.length
+          SpeakeasyRubySdk::Masker::SIMPLE_MASK
+        else
+          @masks[i]
+        end
+      end
+    end
+  end
+
+  class Masker
+
+    SIMPLE_MASK = '__masked__'
+    SIMPLE_NUMBER_MASK = -12321
+
+    def initialize config
+      @masks = {
+        :query_params => [],
+        :request_headers => [],
+        :response_headers => [],
+        :request_cookies => [],
+        :response_cookies => [],
+        :request_body_string => [],
+        :request_body_number => [],
+        :response_body_string => [],
+        :response_body_number => []
+      }
+      # todo remove this dependency for other mask control
+      @routes = config.routes
+
+      if config.masking
+        config.masking.map {|mask| @masks[mask.type] << mask}
+      end
+    end
+
+    def mask_value mask, attribute, path
+      if !mask.controller.nil?
+        route = @routes.recognize_path path
+        if mask.controller === route[:prefix]
+          return mask.get_mask_for_attribute attribute
+        else
+          return value;
+        end
+      else
+        return mask.get_mask_for_attribute attribute
+      end      
+    end
+
+    def mask_pair masking_key, path, attribute, value
+      masked_value = value
+      if @masks.include? masking_key
+        masks = @masks[masking_key]
+        for mask in masks
+          if mask.attributes.include? attribute.to_s.downcase
+            masked_value = mask_value mask, attribute, path
+          end
+        end
+      end
+      return masked_value
+    end
+    
+    def mask_dict masking_key, path, hash_map
+      masked_dict = {}
+      for key, value in hash_map
+        masked_dict[key] = mask_pair masking_key, path, key, value
+        if value.is_a? Array
+          masked_dict[key] = value.map { |v| mask_pair masking_key, path, key, v }
+        end
+      end
+      masked_dict
+    end
+
+    def mask_query_params path, query_params
+      mask_dict :query_params, path, query_params
+    end
+
+    def mask_request_headers path, headers
+      mask_dict :request_headers, path, headers
+    end
+
+    def mask_response_headers path, headers
+      mask_dict :response_headers, path, headers
+    end
+
+    def mask_request_cookies path, cookies
+      mask_dict :request_cookies, path, cookies
+    end
+
+    def mask_response_cookies path, cookies
+      for cookie in cookies
+        key = cookie.name
+        value = cookie.value
+        masked_value = self.mask_pair :response_cookies, path, key, value
+        cookie.value = masked_value
+      end
+      cookies
+    end
+
+    def mask_body_string masking_key_prefix, path, body
+      masking_key = "#{masking_key_prefix}_string".to_sym
+
+      masked_body = body
+      if @masks.include? masking_key
+        for mask in @masks[masking_key]
+          for attribute in mask.attributes
+
+            regex_string = Regexp.new "(\"#{attribute}\": *)(\".*?[^\\\\]\")( *[, \\n\\r}]?)"
+            
+            matches = body.match(regex_string)
+            if matches
+              masked_body = masked_body.gsub(regex_string, "#{matches[1]}\"#{mask.get_mask_for_attribute(attribute)}\"#{matches[3]}")
+            end
+          end
+        end
+      end
+      masked_body
+    end
+    def mask_body_number masking_key_prefix, path, body
+      masking_key = "#{masking_key_prefix}_number".to_sym
+
+      masked_body = body
+      if @masks.include? masking_key
+        for mask in @masks[masking_key]
+          for attribute in mask.attributes
+            regex_string = Regexp.new "(\"#{attribute}\": *)(-?[0-9]+\\.?[0-9]*)( *[, \\n\\r}]?)"
+            matches = body.match(regex_string)
+            if matches
+              masked_body = masked_body.gsub(regex_string, "#{matches[1]}#{mask.get_mask_for_attribute(attribute)}#{matches[3]}")
+            end
+          end
+        end
+      end
+      masked_body
+    end
+
+    def mask_request_body path, body
+      masked_body = mask_body_string 'request_body', path, body
+      mask_body_number 'request_body', path, masked_body
+    end
+
+    def mask_response_body path, body
+      masked_body = mask_body_string 'response_body', path, body
+      mask_body_number 'response_body', path, masked_body
+    end
+
+  end
+end
+
+

data/lib/speakeasy_ruby_sdk/time.rb

@@ -0,0 +1,42 @@
+module SpeakeasyRubySdk
+  class TimeUtils
+    ## Convenience class to optionally override times
+    ## In test environment
+    def initialize(start_time=nil, elapsed_time=nil)
+      @start_time = start_time
+      @elapsed_time = elapsed_time
+      @end_time = nil
+    end
+    
+    def start_time
+      now
+    end
+
+    def now
+      if @start_time.nil?
+        @start_time
+        @start_time = Time.now
+        return @start_time
+      else
+        return @start_time
+      end
+    end
+
+    def set_end_time
+      @end_time = Time.now
+    end
+
+    def elapsed_time
+      if !@elapsed_time.nil?
+        return @elapsed_time
+      else
+        @elapsed_time = time_difference(@end_time, @start_time)
+      end
+    end
+
+    def time_difference end_time, start_time
+      ((end_time - start_time)).to_i
+    end
+
+  end
+end

data/lib/speakeasy_ruby_sdk/url_utils.rb

@@ -0,0 +1,24 @@
+require 'uri'
+module SpeakeasyRubySdk
+  module UrlUtils
+    def self.resolve_url env, query_params=nil
+      if env.include?('SERVER_PORT') && env['SERVER_PORT'] != "80"
+        request_uri = "#{env['SERVER_NAME']}:#{env['SERVER_PORT']}#{env['PATH_INFO']}"
+      else
+        request_uri = "#{env['SERVER_NAME']}#{env['PATH_INFO']}"
+      end
+
+      if request_uri.include? '?'
+        request_uri = request_uri.split('?')[0]
+      end
+      scheme = env['rack.url_scheme']
+      host = env['HTTP_HOST']
+      if !query_params.nil? && !query_params.empty?
+        updated_query_string = URI.encode_www_form query_params
+        URI("#{scheme}://#{host}#{request_uri}?#{updated_query_string}")
+      else 
+        URI("#{scheme}://#{host}#{request_uri}")
+      end
+    end
+  end
+end

data/lib/speakeasy_ruby_sdk/version.rb

@@ -0,0 +1,3 @@
+module SpeakeasyRubySdk
+  VERSION = '0.0.2'
+end