newrelic_rpm 3.7.0.177 → 3.7.1.180

data/test/flaky_proxy/lib/flaky_proxy.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+$: << File.expand_path(File.dirname(__FILE__))
+
+require 'logger'
+
+require 'flaky_proxy/server'
+require 'flaky_proxy/connection'
+require 'flaky_proxy/http_message'
+require 'flaky_proxy/rule'
+require 'flaky_proxy/rule_set'
+require 'flaky_proxy/proxy'
+
+module FlakyProxy
+  @logger = Logger.new($stderr)
+
+  def self.logger
+    @logger
+  end
+end

data/test/flaky_proxy/lib/flaky_proxy/connection.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+module FlakyProxy
+  class Connection
+    def initialize(client_socket, server, rules)
+      @client_socket = client_socket
+      @server_socket = nil
+      @server = server
+      @rules = rules
+    end
+
+    def client_socket
+      @client_socket
+    end
+
+    def server_socket
+      @server_socket ||= @server.open_socket
+    end
+
+    def shutdown
+      @client_socket.close if @client_socket && !@client_socket.closed?
+      @server_socket.close if @server_socket && !@server_socket.closed?
+      @shutdown = true
+    end
+
+    def service
+      loop do
+        service_one
+        break if @shutdown
+      end
+    end
+
+    def service_one
+      request = Request.read_from(client_socket)
+      if request.complete?
+        rule = @rules.match(request)
+        rule.evaluate(request, self)
+      else
+        shutdown
+      end
+    end
+  end
+end

data/test/flaky_proxy/lib/flaky_proxy/http_message.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+require 'http/parser'
+require 'webrick'
+
+module FlakyProxy
+  MAXBUF = 10 * 4096 # 40KB
+
+  class HttpMessage
+    def self.read_from(io)
+      msg = self.new
+      msg.read(io)
+      msg
+    end
+
+    attr_reader :raw_data
+
+    def initialize
+      @parser = Http::Parser.new
+      @raw_data = ''
+      @complete = false
+      @parser.on_message_complete = proc do |env|
+        @complete = true
+      end
+    end
+
+    def request_url
+      @parser.request_url if complete?
+    end
+
+    def request_path
+      @parser.request_path if complete?
+    end
+
+    def <<(data)
+      @raw_data << data
+      @parser << data
+    end
+
+    def read(io)
+      loop do
+        return if complete? || io.closed?
+        ready = select([io])
+        if ready && ready.first.include?(io)
+          if io.eof?
+            return
+          else
+            self << io.readpartial(MAXBUF)
+          end
+        end
+      end
+    end
+
+    def complete?
+      @complete
+    end
+
+    def relay_to(io)
+      io.write(@raw_data)
+    end
+  end
+
+  class Request < HttpMessage
+    def request_method
+      @parser.http_method
+    end
+  end
+
+  class Response < HttpMessage
+    def self.build(options={})
+      defaults = {
+        :status => 200,
+        :headers => {},
+        :body => ''
+      }
+      options = defaults.merge(options)
+      status_line = build_status_line(options[:status])
+      headers = build_headers(options[:body], options[:headers])
+
+      rsp = self.new
+      rsp << status_line
+      rsp << headers
+      rsp << "\r\n"
+      rsp << options[:body]
+      rsp
+    end
+
+    def self.build_status_line(status)
+      status_text = WEBrick::HTTPStatus::StatusMessage[status]
+      "HTTP/1.1 #{status} #{status_text}\r\n"
+    end
+
+    def self.build_headers(body, headers)
+      default_headers = {
+        'Content-Length' => body.bytesize
+      }
+      headers = default_headers.merge(headers)
+      headers.map do |key, value|
+        "#{key}: #{value}\r\n"
+      end.join
+    end
+  end
+end

data/test/flaky_proxy/lib/flaky_proxy/proxy.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+require 'socket'
+
+module FlakyProxy
+  class Proxy
+    def initialize(options)
+      @listen_host = options.fetch(:listen_host)
+      @listen_port = options.fetch(:listen_port)
+      @backend_server = Server.new(options.fetch(:target_host), options.fetch(:target_port))
+      @rules = RuleSet.build('')
+      @rules_path = options[:rules_path]
+      @listen_socket = nil
+    end
+
+    def reload_rules_file
+      if @rules_path
+        mtime = File.stat(@rules_path).mtime
+        if @last_rules_mtime.nil? || mtime > @last_rules_mtime
+          FlakyProxy.logger.info("Reloading rules file at #{@rules_path}")
+          @rules = RuleSet.build(File.read(@rules_path))
+          @last_rules_mtime = mtime
+        end
+      end
+    end
+
+    def run
+      FlakyProxy.logger.info("Starting FlakyProxy on #{@listen_host}:#{@listen_port} -> #{@backend_server.to_s}")
+      @listen_socket = TCPServer.new(@listen_host, @listen_port)
+      loop do
+        client_socket = @listen_socket.accept
+        reload_rules_file
+        FlakyProxy.logger.info("Accepted connection from #{client_socket}")
+        connection = Connection.new(client_socket, @backend_server, @rules)
+        connection.service
+        FlakyProxy.logger.info("Finished servicing connection from #{client_socket}")
+      end
+    end
+  end
+end

data/test/flaky_proxy/lib/flaky_proxy/rule.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+module FlakyProxy
+  class Rule
+    class ActionBuilder
+      def initialize(rule)
+        @actions = []
+        @rule = rule
+      end
+
+      def pass
+        @rule.actions << [:pass]
+      end
+
+      def respond(response_spec)
+        @rule.actions << [:respond, response_spec]
+      end
+
+      def delay(amount)
+        @rule.actions << [:delay, amount]
+      end
+
+      def close
+        @rule.actions << [:close]
+      end
+    end
+
+    attr_reader :actions
+
+    def initialize(url_regex=nil, &blk)
+      @url_regex = url_regex
+      @actions = []
+      ActionBuilder.new(self).instance_eval(&blk)
+    end
+
+    def match?(request)
+      @url_regex.nil? || @url_regex.match(request.request_url)
+    end
+
+    def next_action
+      if @actions.size > 1
+        @actions.shift
+      else
+        @actions.last
+      end
+    end
+
+    def relay(request, connection)
+      request.relay_to(connection.server_socket)
+      response = Response.read_from(connection.server_socket)
+      response.relay_to(connection.client_socket)
+    end
+
+    def evaluate(request, connection)
+      action, *params = next_action
+      FlakyProxy.logger.info("    [#{action.upcase}] #{request.request_method} #{request.request_url}")
+      case action
+      when :pass
+        relay(request, connection)
+      when :respond
+        response_spec = params.first
+        response = Response.build(response_spec)
+        response.relay_to(connection.client_socket)
+      when :delay
+        amount = params.first
+        sleep(amount)
+        relay(request, connection)
+      when :close
+        connection.client_socket.close
+      end
+    end
+  end
+end

data/test/flaky_proxy/lib/flaky_proxy/rule_set.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+module FlakyProxy
+  class RuleSet
+    class Builder
+      attr_reader :rules
+
+      def initialize(ruleset, &blk)
+        @ruleset = ruleset
+        @rules = []
+      end
+
+      def match(criteria, &blk)
+        @ruleset.rules << Rule.new(criteria, &blk)
+      end
+    end
+
+    def self.build(text=nil, &blk)
+      ruleset = self.new
+      Builder.new(ruleset).instance_eval(text, &blk)
+      ruleset
+    end
+
+    attr_accessor :rules
+
+    def initialize
+      @rules = []
+      @default_rule = Rule.new { pass }
+    end
+
+    def match(request)
+      @rules.detect { |rule| rule.match?(request) } || @default_rule
+    end
+  end
+end

data/test/flaky_proxy/lib/flaky_proxy/server.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+module FlakyProxy
+  class Server
+    attr_reader :host, :port
+
+    def initialize(host, port)
+      @host = host
+      @port = port
+    end
+
+    def open_socket
+      TCPSocket.new(@host, @port)
+    end
+
+    def to_s
+      "#{@host}:#{@port}"
+    end
+  end
+end

data/test/flaky_proxy/script/flaky_proxy

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'flaky_proxy')
+
+DEFAULTS = {
+  :listen_host => 'localhost',
+  :listen_port => 8888,
+  :target_host => 'localhost',
+  :target_port => 8081
+}
+
+options = DEFAULTS.dup
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: #{$0} [options] [<rules file>]"
+
+  opts.on("-l", "--listen [<HOST>:]<PORT>", "Specify the host and port to listen on") do |listen_spec|
+    if listen_spec =~ /^([^:]+):(\d+)$/
+      options[:listen_host] = $1
+      options[:listen_port] = $2.to_i
+    else
+      options[:listen_port] = listen_spec.to_i
+    end
+  end
+
+  opts.on("-t", "--target [<HOST>:]<PORT>", "Specify the host and port to forward to") do |target_spec|
+    if target_spec =~ /^([^:]+):(\d+)$/
+      options[:target_host] = $1
+      options[:target_port] = $2
+    else
+      options[:target_port] = target_spec.to_i
+    end
+  end
+end
+parser.parse!
+
+options[:rules_path] = ARGV[0] if ARGV[0]
+
+FlakyProxy::Proxy.new(options).run

data/test/helpers/exceptions.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+module NewRelic
+  module TestHelpers
+    module Exceptions
+      class TestError < StandardError; end
+      class IgnoredError < StandardError; end
+      class ServerIgnoredError < StandardError; end
+      class TestRuntimeError < RuntimeError; end
+      class ParentException < Exception; end
+      class ChildException < ParentException; end
+    end
+  end
+end

data/test/helpers/mongo_metric_builder.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+require 'new_relic/agent/datastores/mongo/metric_translator'
+
+module NewRelic
+  module TestHelpers
+    module MongoMetricBuilder
+      def build_test_metrics(name, request_type = :web)
+        NewRelic::Agent::Datastores::Mongo::MetricTranslator.build_metrics(
+          name,
+          @collection_name,
+          request_type
+        )
+      end
+
+      def metrics_with_attributes(metrics, attributes)
+        metric_attributes = {}
+
+        metrics.each do |metric|
+          metric_attributes[metric] = attributes
+        end
+
+        metric_attributes
+      end
+    end
+  end
+end