ffwd 0.1.0

data/lib/ffwd/protocol.rb

@@ -0,0 +1,28 @@
+# $LICENSE
+# Copyright 2013-2014 Spotify AB. All rights reserved.
+#
+# The contents of this file are licensed under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with the
+# License. You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+require_relative 'protocol/udp'
+require_relative 'protocol/tcp'
+
+module FFWD
+  def self.parse_protocol(original)
+    string = original.downcase
+
+    return UDP if string == "udp"
+    return TCP if string == "tcp"
+
+    throw "Unknown protocol '#{original}'"
+  end
+end

data/lib/ffwd/protocol/tcp.rb

@@ -0,0 +1,126 @@
+# $LICENSE
+# Copyright 2013-2014 Spotify AB. All rights reserved.
+#
+# The contents of this file are licensed under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with the
+# License. You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+require 'eventmachine'
+
+require_relative '../tunnel'
+
+require_relative 'tcp/bind'
+require_relative 'tcp/plain_connect'
+require_relative 'tcp/flushing_connect'
+require_relative 'tcp/connection'
+
+module FFWD::TCP
+  def self.family
+    :tcp
+  end
+
+  # default amount of bytes that the outbound connection will allow in its
+  # application-level buffer.
+  DEFAULT_OUTBOUND_LIMIT = 2 ** 20
+  # default flush period, if non-zero will cause the connection to be buffered.
+  DEFAULT_FLUSH_PERIOD = 10
+  # defaults for buffered connections.
+  # maximum amount of events to buffer up.
+  DEFAULT_EVENT_LIMIT = 1000
+  # maximum amount of metrics to buffer up.
+  DEFAULT_METRIC_LIMIT = 10000
+  # percent of maximum events/metrics which will cause a flush.
+  DEFAULT_FLUSH_LIMIT = 0.8
+  # Default initial timeout when binding fails.
+  DEFAULT_REBIND_TIMEOUT = 10
+
+  # Establish an outbound tcp connection.
+  #
+  # opts - Option hash.
+  #   Expects the following keys.
+  #     :host - The host to connect to.
+  #     :port - The port to connect to.
+  #     :outbound_limit - The amount of bytes that are allowed to be pending in
+  #     the application level buffer for the connection to be considered
+  #     'writable'.
+  #     :flush_period - The period in which outgoing data is buffered. If this
+  #     is 0 no buffering will occur.
+  #   Reads the following keys if the connection is buffered.
+  #     :event_limit - The maximum amount of events the connection is allowed
+  #     to buffer up.
+  #     :metric_limimt - The maximum amount of metrics the connection is
+  #     allowed to buffer up.
+  #     :flush_limit - A percentage (0.0 - 1.0) indicating 'the percentage of
+  #     events/metrics' that is required for a flush to be forced.
+  #     If this percentage is reached, the connection will attempt to forcibly
+  #     flush all buffered events and metrics prior to the end of the flushing
+  #     period.
+  # core - The core interface associated with this connection.
+  # log - The logger to use for this connection.
+  # handler - An implementation of FFWD::Handler containing the connection
+  # logic.
+  # args - Arguments passed to the handler when a new instance is created.
+  def self.connect opts, core, log, handler, *args
+    raise "Missing required option :host" if (host = opts[:host]).nil?
+    raise "Missing required option :port" if (port = opts[:port]).nil?
+
+    outbound_limit = opts[:outbound_limit] || DEFAULT_OUTBOUND_LIMIT
+    flush_period = opts[:flush_period] || DEFAULT_FLUSH_PERIOD
+
+    connection = Connection.new log, host, port, handler, args, outbound_limit
+
+    if flush_period == 0
+      PlainConnect.new core, log, connection
+    else
+      event_limit = opts[:event_limit] || DEFAULT_EVENT_LIMIT
+      metric_limit = opts[:metric_limit] || DEFAULT_METRIC_LIMIT
+      flush_limit = opts[:flush_limit] || DEFAULT_FLUSH_LIMIT
+
+      FlushingConnect.new(
+        core, log, connection,
+        flush_period, event_limit, metric_limit, flush_limit
+      )
+    end
+  end
+
+  # Bind and listen for a TCP connection.
+  #
+  # opts - Option hash.
+  #   :host - The host to bind to.
+  #   :port - The port to bind to.
+  #   :rebind_timeout - The initial timeout to use when rebinding the
+  #   connection.
+  # core - The core interface associated with this connection.
+  # log - The logger to use for this connection.
+  # connection - An implementation of FFWD::Connection containing the
+  # connection logic.
+  # args - Arguments passed to the connection when a new instance is created.
+  def self.bind opts, core, log, connection, *args
+    raise "Missing required option :host" if (host = opts[:host]).nil?
+    raise "Missing required option :port" if (port = opts[:port]).nil?
+    rebind_timeout = opts[:rebind_timeout] || DEFAULT_REBIND_TIMEOUT
+    Bind.new core, log, host, port, connection, args, rebind_timeout
+  end
+
+  # Set up a TCP tunnel.
+  #
+  # opts - Option hash.
+  #   :port - The port to bind to on the remote side.
+  # core - The core interface associated with this connection.
+  # log - The logger to use for this connection.
+  # connection - An implementation of FFWD::Connection containing the
+  # connection logic.
+  # args - Arguments passed to the connection when a new instance is created.
+  def self.tunnel opts, core, plugin, log, connection, *args
+    raise "Missing required option :port" if (port = opts[:port]).nil?
+    FFWD.tunnel self.family, port, core, plugin, log, connection, args
+  end
+end

data/lib/ffwd/protocol/tcp/bind.rb

@@ -0,0 +1,64 @@
+# $LICENSE
+# Copyright 2013-2014 Spotify AB. All rights reserved.
+#
+# The contents of this file are licensed under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with the
+# License. You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+require 'eventmachine'
+
+require_relative '../../reporter'
+require_relative '../../retrier'
+
+module FFWD::TCP
+  class Bind
+    include FFWD::Reporter
+
+    setup_reporter :keys => [
+      :received_events, :received_metrics,
+      :failed_events, :failed_metrics
+    ]
+
+    attr_reader :reporter_meta
+
+    def initialize core, log, host, port, connection, args, rebind_timeout
+      @peer = "#{host}:#{port}"
+      @reporter_meta = {
+        :type => connection.plugin_type,
+        :listen => @peer, :family => 'tcp'
+      }
+
+      @sig = nil
+
+      info = "tcp://#{@peer}"
+
+      r = FFWD.retry :timeout => rebind_timeout do |a|
+        @sig = EM.start_server host, port, connection, self, core, *args
+        log.info "Bind on #{info} (attempt #{a})"
+      end
+
+      r.error do |a, t, e|
+        log.error "Failed to bind #{info} (attempt #{a}), retry in #{t}s", e
+      end
+
+      r.depend_on core
+
+      core.stopping do
+        log.info "Unbinding #{info}"
+
+        if @sig
+          EM.stop_server @sig
+          @sig = nil
+        end
+      end
+    end
+  end
+end

data/lib/ffwd/protocol/tcp/connection.rb

@@ -0,0 +1,107 @@
+# $LICENSE
+# Copyright 2013-2014 Spotify AB. All rights reserved.
+#
+# The contents of this file are licensed under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with the
+# License. You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+module FFWD::TCP
+  class Connection
+    INITIAL_TIMEOUT = 2
+
+    attr_reader :log, :peer, :reporter_meta
+
+    def initialize log, host, port, handler, args, outbound_limit
+      @log = log
+      @host = host
+      @port = port
+      @handler = handler
+      @args = args
+      @outbound_limit = outbound_limit
+
+      @peer = "#{host}:#{port}"
+      @closing = false
+      @reconnect_timeout = INITIAL_TIMEOUT
+      @reporter_meta = {:type => @handler.plugin_type, :peer => peer}
+
+      @timer = nil
+      @c = nil
+      @open = false
+    end
+
+    # Start attempting to connect.
+    def connect
+      log.info "Connecting to tcp://#{@host}:#{@port}"
+      @c = EM.connect @host, @port, @handler, self, *@args
+    end
+
+    # Explicitly disconnect and discard any reconnect attempts..
+    def disconnect
+      log.info "Disconnecting from tcp://#{@host}:#{@port}"
+      @closing = true
+
+      @c.close_connection if @c
+      @timer.cancel if @timer
+      @c = nil
+      @timer = nil
+    end
+
+    def send_event event
+      @c.send_event event
+    end
+
+    def send_metric metric
+      @c.send_metric metric
+    end
+
+    def send_all events, metrics
+      @c.send_all events, metrics
+    end
+
+    def connection_completed
+      @open = true
+      @log.info "Connected tcp://#{peer}"
+      @reconnect_timeout = INITIAL_TIMEOUT
+
+      unless @timer.nil?
+        @timer.cancel
+        @timer = nil
+      end
+    end
+
+    def unbind
+      @open = false
+      @c = nil
+
+      if @closing
+        return
+      end
+
+      @log.info "Disconnected from tcp://#{peer}, reconnecting in #{@reconnect_timeout}s"
+
+      unless @timer.nil?
+        @timer.cancel
+        @timer = nil
+      end
+
+      @timer = EM::Timer.new(@reconnect_timeout) do
+        @reconnect_timeout *= 2
+        @timer = nil
+        @c = EM.connect @host, @port, @handler, self, *@args
+      end
+    end
+
+    # Check if a connection is writable or not.
+    def writable?
+      not @c.nil? and @open and @c.get_outbound_data_size < @outbound_limit
+    end
+  end
+end

data/lib/ffwd/protocol/tcp/flushing_connect.rb

@@ -0,0 +1,135 @@
+# $LICENSE
+# Copyright 2013-2014 Spotify AB. All rights reserved.
+#
+# The contents of this file are licensed under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with the
+# License. You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+require_relative '../../reporter'
+
+module FFWD::TCP
+  # A TCP connection implementation that buffers events and metrics in batches
+  # over a time window and calls 'send_all' on the connection.
+  class FlushingConnect
+    include FFWD::Reporter
+
+    setup_reporter :keys => [
+      :dropped_events, :dropped_metrics,
+      :sent_events, :sent_metrics,
+      :failed_events, :failed_metrics,
+      :forced_flush
+    ]
+
+    attr_reader :log
+
+    def reporter_meta
+      @c.reporter_meta
+    end
+
+    def initialize(
+      core, log, connection,
+      flush_period, event_limit, metric_limit, flush_limit
+    )
+      @log = log
+      @c = connection
+
+      @flush_period = flush_period
+      @event_limit = event_limit
+      @event_flush_limit = flush_limit * event_limit
+      @metric_limit = metric_limit
+      @metric_flush_limit = flush_limit * metric_limit
+
+      @event_buffer = []
+      @metric_buffer = []
+      @timer = nil
+
+      subs = []
+
+      core.starting do
+        log.info "Flushing every #{@flush_period}s"
+        @timer = EM::PeriodicTimer.new(@flush_period){flush!}
+
+        event_consumer = setup_consumer(
+          @event_buffer, @event_limit, @event_flush_limit, :dropped_events)
+        metric_consumer = setup_consumer(
+          @metric_buffer, @metric_limit, @metric_flush_limit, :dropped_metrics)
+
+        subs << core.output.event_subscribe(&event_consumer)
+        subs << core.output.metric_subscribe(&metric_consumer)
+
+        @c.connect
+      end
+
+      core.stopping do
+        subs.each(&:unsubscribe).clear
+
+        if @timer
+          @timer.cancel
+          @timer = nil
+        end
+
+        @c.disconnect
+      end
+    end
+
+    def flush!
+      if @event_buffer.empty? and @metric_buffer.empty?
+        return
+      end
+
+      unless @c.writable?
+        increment :dropped_events, @event_buffer.size
+        increment :dropped_metrics, @metric_buffer.size
+        return
+      end
+
+      @c.send_all @event_buffer, @metric_buffer
+      increment :sent_events, @event_buffer.size
+      increment :sent_metrics, @metric_buffer.size
+    rescue => e
+      log.error "Failed to flush buffers", e
+
+      log.error "The following data could not be flushed:"
+
+      @event_buffer.each_with_index do |event, i|
+        log.error "##{i}: #{event.to_h}"
+      end
+
+      @metric_buffer.each_with_index do |metric, i|
+        log.error "##{i}: #{metric.to_h}"
+      end
+
+      increment :failed_events, @event_buffer.size
+      increment :failed_metrics, @metric_buffer.size
+    ensure
+      @event_buffer.clear
+      @metric_buffer.clear
+    end
+
+    private
+
+    def setup_consumer buffer, buffer_limit, flush_limit, statistics_key
+      proc do |e|
+        if buffer.size >= buffer_limit
+          increment statistics_key, 1
+          next
+        end
+
+        buffer << e
+
+        if buffer.size >= flush_limit
+          increment :forced_flush, 1
+          flush!
+        end
+      end
+    end
+  end
+end