statscloud 1.0.1

data/lib/statscloud/helpers/socketio_helper.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative './logger_helper'
+
+module StatsCloud
+  # This helper works to create socket connection.
+  module SocketIOHelper
+    private
+
+    include StatsCloud::LoggerHelper
+
+    def open?
+      !@client.nil? && @client.open?
+    end
+
+    def connect_client(url, token)
+      eventmachine.run do
+        eventmachine.add_periodic_timer(5) do
+          try_connect(url, token)
+          eventmachine.add_timer(3) { send_tags && eventmachine.stop if connected? }
+        end
+        eventmachine.add_timer(300.01) { stop_machine unless @client }
+      end
+    end
+
+    def try_connect(url, token)
+      @client = socketio_client.connect url, path: '/ws', 'auth-token' => token
+      listen_connect
+      listen_events
+      listen_errors
+    rescue StandardError => error
+      logger.error error
+      close
+    end
+
+    def listen_connect
+      this = self
+
+      @client.on :connect do
+        this.logger.info 'StatsCloud client has connected to StatsCloud server'
+      end
+    end
+
+    def listen_events
+      this = self
+
+      @client.on :events do |names_map|
+        this.names_map = names_map
+        this.event_name_size_in_bytes = (Math.log(names_map.keys.length) / Math.log(256)).ceil
+        this.event_name_size_in_bytes = 1 if this.event_name_size_in_bytes < 1
+      end
+    end
+
+    def listen_errors
+      this = self
+
+      @client.on :error do |error|
+        this.logger.error error
+      end
+    end
+
+    def send_tags
+      @client.emit :tags, @tags
+    end
+
+    def stop_machine
+      eventmachine.stop
+      Thread.stop
+    end
+
+    def eventmachine
+      EM
+    end
+
+    def socketio_client
+      ::StatsCloudIO::SocketIO::Client::Simple
+    end
+  end
+end

data/lib/statscloud/helpers/statscloud_helper.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'leon'
+
+module StatsCloud
+  # This helper configures StatsCloud::Client.
+  module StatsCloudHelper
+    private
+
+    def config_environment(env)
+      @env = env
+    end
+
+    def config_tags(tags)
+      @tags = tags
+    end
+
+    def env
+      @env ||= @config['environment'] || ENV['RAILS_ENV'] || 'default'
+    end
+
+    def tags
+      @tags ||= @config['tags'] || [os.gethostname]
+    end
+
+    def error_message
+      "statscloud.io #{@app} cluster have failed to deploy. #{@cluster[:status][:error]}"
+    end
+
+    def successful_message
+      "statscloud.io support configured, dashboard URLs are \n #{(@cluster[:grafanaDashboardsUrls] || []).join("\n")}"
+    end
+
+    def os
+      Socket
+    end
+  end
+end

data/lib/statscloud/helpers/statsmeter_helper.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'leon'
+
+module StatsCloud
+  # This helper configures StatsmeterClient.
+  module StatsmeterHelper
+    private
+
+    def set_config(url, token, tags)
+      @url = url
+      @token = token
+      @tags = tags.map { |t| t.gsub(/[^a-z0-9_-]/, '_') }
+    end
+
+    def set_client_to_nil
+      @client = nil
+    end
+
+    def set_pending_values
+      @pending_plain_events = buffer.new
+      @pending_plain_offset = 0
+      @pending_binary_events = buffer.new
+      @pending_binary_offset = 0
+    end
+
+    def set_socket_values
+      @names_map = {}
+      @event_name_size_in_bytes = 0
+    end
+
+    def record_binary_event(name, measurement, binary_length)
+      @pending_binary_events.writeInt8(@names_map[name], @pending_binary_offset)
+      measurement.zero? ? record_binary_zero : record_binary_measurement(measurement)
+      @pending_binary_offset += binary_length
+    end
+
+    def record_binary_measurement(data)
+      @pending_binary_events.writeFloatBE(data, (@pending_binary_offset + @event_name_size_in_bytes))
+    end
+
+    def record_plain_measurement(data, name)
+      @pending_plain_events.writeFloatBE(data, @pending_plain_offset + name.length + 1)
+    end
+
+    def record_binary_zero
+      @pending_binary_events.writeInt32BE(0, (@pending_binary_offset + @event_name_size_in_bytes))
+    end
+
+    def record_plain_zero(name)
+      record_zero(@pending_plain_events, @pending_plain_offset + name.length + 1)
+    end
+
+    def record_zero(buffer, offset)
+      buffer.writeInt32BE(0, offset)
+    end
+
+    def record_plain_event(name, measurement, plain_length)
+      @pending_plain_events.write(name, @pending_plain_offset)
+      if measurement
+        @pending_plain_events.write(',', @pending_plain_offset + name.length)
+        measurement.zero? ? record_plain_zero(name) : record_plain_measurement(measurement, name)
+      end
+      @pending_plain_events.write(';', @pending_plain_offset + plain_length - 1)
+      @pending_plain_offset += plain_length
+    end
+
+    def buffer
+      ::LEON::StringBuffer
+    end
+  end
+end

data/lib/statscloud/statscloud_client.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'json'
+require 'eventmachine'
+require 'singleton'
+require 'socket'
+require_relative 'version'
+require_relative 'statsmeter_client'
+require_relative 'cluster_client'
+require_relative 'helpers/assets_helper'
+require_relative 'helpers/logger_helper'
+require_relative 'helpers/statscloud_helper'
+
+module StatsCloud
+  # Module which implements StatsCloud framework support.
+  class Client
+    include Singleton
+    include AssetsHelper
+    include LoggerHelper
+    include StatsCloud::StatsCloudHelper
+
+    # Configures statsmeter.io support for application and initializes a statscloud.io client.
+    #
+    # @param [+String] env
+    #   statsmeter.io cluster environment
+    #
+    # @param [+Hash+] base_config
+    #   statsmeter.io configuration
+    #
+    # @return [Thread]
+    #
+    # @api public
+    def start(base_config = nil)
+      initialize_values
+      generate_configuration(base_config)
+      collect_statscloud_assets(@config, @source_mappings)
+      config_values
+      clear_data
+      configure_cluster
+      connect_to_cluster
+    end
+
+    # Configures Statscloud environment.
+    #
+    # @return StatsCloud::Client
+    def with_environment(env)
+      config_environment(env)
+      self
+    end
+
+    # Configures Statscloud tags.
+    #
+    # @return StatsCloud::Client
+    def with_tags(tags)
+      config_tags(tags)
+      self
+    end
+
+    # Returns statscloud.io client aka Statsmeter client
+    #
+    # @return [StatsCloud::StatsmeterClient]
+    #
+    # @api public
+    def meter
+      @statsmeter_client
+    end
+
+    # Returns cluster status.
+    #
+    # @return [Hash]
+    #
+    # @api public
+    def cluster_status
+      return unless @cluster_client
+      cluster = @cluster_client.get_cluster(@token, @app)&.body
+      cluster[:status][:status] if cluster
+    end
+
+    # Stops statscloud.io service.
+    #
+    # @return [NilClass]
+    #
+    # @api public
+    def stop
+      @statsmeter_client&.close
+      @statsmeter_client = nil
+      @cluster_client&.undeploy_cluster(@token, @app)
+      @cluster_client = nil
+    end
+
+    private
+
+    attr_reader :config, :source_mappings, :statsmeter_client, :cluster, :token, :app, :graphite_url
+
+    def initialize_values
+      @config = {}
+      @source_mappings = { metrics: [], admins: [], dashboards: [], alerts: [] }
+    end
+
+    def generate_configuration(base_config)
+      if base_config
+        join_configs(@config, base_config, @source_mappings, '')
+      else
+        base_config = get_config_from_file(File.join(__dir__, '.statscloud.yml'))
+        join_configs(@config, base_config, @source_mappings, '.statscloud.yml')
+      end
+    end
+
+    def config_values
+      @config['sourceMaps'] = source_mappings
+      @token = @config['token']
+      @app = @config['application']
+    end
+
+    def clear_data
+      @config.delete('propagateErrors')
+      @config.delete('token')
+    end
+
+    def configure_cluster
+      @cluster_client = create_cluster_client
+      @cluster_client.deploy_cluster(@token, @app, @config)
+      @cluster = @cluster_client.get_cluster(@token, @app).body
+      @graphite_url = @cluster[:graphiteUrl]
+      check_cluster_status
+      logger.info successful_message
+    end
+
+    def check_cluster_status
+      raise error if @cluster[:status][:status] == 'ERROR'
+    end
+
+    def error
+      logger.error error_message
+      StandardError.new(error_message)
+    end
+
+    def connect_to_cluster
+      @statsmeter_client = create_statsmeter_client(@cluster, @token, tags)
+      @statsmeter_client.connect
+    end
+
+    def create_cluster_client
+      StatsCloud::ClusterClient.new(env)
+    end
+
+    def create_statsmeter_client(cluster, token, tags)
+      host = cluster[:statsmeterUrl]
+      StatsCloud::StatsmeterClient.new(host, token, tags)
+    rescue StandardError => e
+      logger.error e
+    end
+  end
+end

data/lib/statscloud/statsmeter_client.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require_relative './helpers/socketio_helper'
+require_relative './helpers/statsmeter_helper'
+require_relative './helpers/logger_helper'
+require_relative './helpers/event_helper'
+require 'leon'
+require 'eventmachine'
+require 'statscloud.io-ruby-socket.io-client-simple'
+require 'crc32'
+
+module StatsCloud
+  # Client for Statsmeter.
+  class StatsmeterClient
+    include StatsCloud::LoggerHelper
+    include StatsCloud::SocketIOHelper
+    include StatsCloud::StatsmeterHelper
+    include StatsCloud::EventHelper
+
+    # Maximum size of pending binary events buffer.
+    BINARY_BUFFER_SIZE = 1024
+
+    # Maximum size of pending binary events buffer.
+    PLAIN_BUFFER_SIZE = 1024 * 100
+
+    # Statsmeter cluster url is used to connect to cluster.
+    #
+    # Type: *String*
+    attr_reader :url
+
+    # Socket connection with statscloud cluster which is used to record events.
+    #
+    # Type: *SocketIO::Client::Simple*
+    attr_accessor :client
+
+    # Metric names.
+    #
+    # Type: *Hash*
+    attr_accessor :names_map
+
+    # Binary size for metric names.
+    #
+    # Type: *Integer*
+    attr_accessor :event_name_size_in_bytes
+
+    # Initialize statsmeter client.
+    #
+    # @param [+String+] url
+    #   statsmeter url.
+    # @param [+String+] token
+    #   authorization token.
+    def initialize(url, token, tags = [])
+      set_config(url, token, tags)
+      set_client_to_nil
+      set_pending_values
+      set_socket_values
+    end
+
+    # Connects to the server and starts periodic sending events.
+    def connect
+      Thread.new do
+        connect_client(@url, @token)
+        flush_events_loop.join if @client
+      end
+    end
+
+    # Records a single event.
+    #
+    # @param [+String+] name
+    #   name of the event to record.
+    # @param [+Integer+] measurement
+    #   optional measurement, depending on metrics type.
+    #
+    # Save event in pending events.
+    def record_event(name, measurement = 0)
+      record_events(name: name, measurement: measurement)
+    end
+
+    # Records several events at once.
+    #
+    # @param [+Array+] events
+    #   events to send (each should have name and optional measurement fields).
+    #
+    # Save events in pending events.
+    def record_events(*events)
+      record_events_array(events)
+    end
+
+    # Records an array of events at once.
+    #
+    # @param [+Array+] events
+    #   array of events to send (each shoud have name and optional measurement fields).
+    #
+    # Save events in pending binary and plain arrays. Check flush condition.
+    def record_events_array(events)
+      events.each do |event|
+        name = get_event_name(event)
+        measurement = get_event_measurement(event)&.to_f
+
+        next unless @names_map && @names_map[name]
+        binary_length = get_binary_length(@event_name_size_in_bytes)
+        plain_length = get_plain_length(name, measurement)
+
+        flush_events if flush_condition(binary_length, plain_length)
+        record_binary_event(name, measurement, binary_length)
+        record_plain_event(name, measurement, plain_length)
+      end
+    end
+
+    # Sends all pending events to statscloud.
+    def flush_events
+      return if @pending_binary_offset.zero?
+      checksum = crc32.calculate(@pending_plain_events.buffer, @pending_plain_offset, 0)
+      return if checksum.zero?
+      @pending_binary_events.writeInt32BE(checksum, @pending_binary_offset)
+      send_message @pending_binary_events
+      set_pending_values
+    rescue StandardError => error
+      logger.error error
+      close
+      connect.join
+    end
+
+    # Shows statsmeter state.
+    def connected?
+      @client&.state == :connect
+    end
+
+    # Stops socket.io connection.
+    def close
+      client.disconnect if open?
+      set_client_to_nil
+    end
+
+    private
+
+    def flush_events_loop
+      Thread.new do
+        eventmachine.run do
+          eventmachine.add_periodic_timer(0.5) do
+            stop_machine unless @client
+            flush_events
+          end
+        end
+      end
+    end
+
+    def send_message(string_buffer)
+      @client.emit :metric, binary_packet(string_buffer.buffer.bytes)
+    end
+
+    def binary_packet(byte_array)
+      socketio_client.as_byte_buffer(byte_array)
+    end
+
+    def flush_condition(binary, plain)
+      @pending_binary_offset + binary > BINARY_BUFFER_SIZE || @pending_plain_offset + plain > PLAIN_BUFFER_SIZE
+    end
+
+    def crc32
+      Crc32
+    end
+  end
+end

data/lib/statscloud/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module StatsCloud
+  # version of statscloud-ruby-client.
+  #
+  # Type: *String*
+  VERSION = '1.0.1'
+end

data/lib/statscloud.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'statscloud/statscloud_client'
+require 'statscloud/helpers/logger_helper'
+
+# StatsCloud.io ruby client
+module StatsCloud
+  class << self
+    include LoggerHelper
+
+    # Configures statsmeter.io support for application and initializes a statscloud.io client.
+    #
+    # @param [+String+] env
+    #   statsmeter.io cluster environment
+    #
+    # @param [+Hash+] base_config
+    #   statsmeter.io configuration
+    #
+    # @return [Thread]
+    #
+    # @api public
+    def start(base_config = nil)
+      StatsCloud::Client.instance.start(base_config)
+    rescue StandardError => error
+      logger.error error
+    end
+
+    # Configures Statscloud environment.
+    #
+    # @return StatsCloud::Client
+    def with_environment(env)
+      StatsCloud::Client.instance.with_environment(env)
+    rescue StandardError => error
+      logger.error error
+    end
+
+    # Configures Statscloud tags.
+    #
+    # @return StatsCloud::Client
+    def with_tags(tags)
+      StatsCloud::Client.instance.with_tags(tags)
+    rescue StandardError => error
+      logger.error error
+    end
+
+    # Returns statscloud.io client aka Statsmeter client
+    #
+    # @return [StatsCloud::StatsmeterClient]
+    #
+    # @api public
+    def meter
+      StatsCloud::Client.instance.meter
+    rescue StandardError => error
+      logger.error error
+    end
+
+    # Returns cluster status.
+    #
+    # @return [Hash]
+    #
+    # @api public
+    def cluster_status
+      StatsCloud::Client.instance.cluster_status
+    rescue StandardError => error
+      logger.error error
+    end
+
+    # Stops statscloud.io service.
+    #
+    # @return [NilClass]
+    #
+    # @api public
+    def stop
+      StatsCloud::Client.instance.stop
+    rescue StandardError => error
+      logger.error error
+    end
+  end
+end

data/lib/templates/statscloud/.statscloud_template.yml

@@ -0,0 +1,16 @@
+---
+token: place-your-token-here
+passwordProtect: false
+application: your-application-name
+flushIntervalInSeconds: 15
+retention:
+  - frequency: 15s
+    keep: 1d
+admins:
+  admin:
+    'phone': place-your-phone-here
+    channels:
+      - sms
+      - voice
+  developer:
+    email: place-your-email-here

data/lib/templates/statscloud/statscloud_template.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+StatsCloud.start
+at_exit { StatsCloud.stop }

data/statscloud.gemspec

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "statscloud/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "statscloud"
+  spec.version       = StatsCloud::VERSION
+  spec.authors       = ["Roman Ovcharov"]
+  spec.email         = ["roman.o.as@agiliumlabs.com"]
+
+  spec.summary       = %q{StatsCloud service.}
+  spec.description   = %q{PaaS application monitoring system.}
+  spec.homepage      = "https://statscloud.io"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport", ">= 5.0.0.1"
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_dependency "crc32", "~> 1.0.1"
+  spec.add_dependency "eventmachine", "~> 1.2"
+  spec.add_dependency "fileutils"
+  spec.add_dependency "leon", "~> 1.1"
+  spec.add_dependency "logger", "~> 1.2"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_dependency "rest-client", "~> 2.0.2"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_dependency "statscloud.io-ruby-socket.io-client-simple", "~> 1.2.1.pre.2"
+end