riemann-ruby-experiments 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7493f64bd96d10b57b58cf47a79390866f8dd92b
+  data.tar.gz: bb4ec0ad7c71c8e898546627f9e1dbe56fb68c2b
+SHA512:
+  metadata.gz: 0e2535d6834d35510036cc013b3fe56638d7b84b131463bc03d600b6ecd3f5d04605cc6eb7946c980a58c7a729737cc816e2ffdeaf2dbe126cd77afd7f741b9f
+  data.tar.gz: 83ced84778692d4a9891c2e11ec5db125f3b3e9b7ee9c23eeadcff6d651ffecbb09b80acceb7a462c9fe7954c992e575f10b119d5115a0a1191fc64ee570ae34

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org
+gemspec

data/README.adoc

@@ -0,0 +1,81 @@
+= riemann-ruby-experiments
+Chris Riddoch <riddochc@gmail.com>
+:language: ruby
+:homepage: https://syntacticsugar.org/projects/riemann-ruby-experiments
+:revnumber: 0.0.3
+:revdate: 2016-05-29
+
+== Description
+
+A Riemann client for ruby
+
+Just another client, to experiment with.
+
+== Requirements
+
+* A riemann server to talk to
+
+== Installation
+
+gem install riemann-ruby-experiments
+
+== Use
+
+Include the following line in your Gemfile:
+
+  gem 'riemann-ruby-experiments'
+
+Then, you can use it like this:
+
+  client = Riemann::Experiment::Client.new(server: "localhost:5555", service: "A new riemann logger!")
+  e1 = {time: Time.now.to_i,
+       description: "An event of some sort",
+       metric: 42.15,
+       anotherkey: "anothervalue"}
+  client.add_event(e1)
+
+  e2 = {time: Time.now.to_i, description: "Another event", metric: 73}
+  client.add_event(e2)
+
+  response = client.send_message()
+
+  if response.ok == 'ok'
+    # acknowledged by server...
+  end
+
+You can also send queries to the Riemann server:
+
+  client = Riemann::Experiment::Client.new()
+  events = client['service = "http/head/mysite"']
+  puts events.first.roundtrip
+
+New attributes can be assigned to an `Riemann::Experiment::Event` object as though
+they were defined on the object with simple attr_accessors.  To create events
+yourself, make sure to call `setup()` on them, passing the client, before doing
+other manipulations (and especially before serializing) in order to make sure
+that client-wide default values are applied correctly.
+
+  e = Riemann::Experiment::Event.new
+  e.setup(client)
+  e.time = Time.now
+  e.website = "http://example.com/"
+  Base64.strict_encode64(e)  # Just for illustration:
+    => "CKyWs7oFGiMuL3JpZW1hbm4tcnVieS1leHBlcmltZW50cy5yYjsxMDU4NyIFdGh5bWVKHgoHd2Vic2l0ZRITaHR0cDovL2V4YW1wbGUuY29tLw=="
+
+For most purposes, though, it's easier to just pass a hash of field values to
+the client's `add_event()` and let it take care of the details.
+
+== Contributing
+
+Pull requests welcome.
+
+== Contributors
+
+* Chris Riddoch
+
+== License
+
+Copyright © 2016 Chris Riddoch
+
+See LICENSE for license details
+

data/Rakefile

@@ -0,0 +1,135 @@
+# vim: syntax=ruby
+
+require 'yaml'
+require 'find'
+require 'asciidoctor'
+require 'erb'
+require 'pry'
+
+def installed_gem_version(name)
+  IO.popen(["gem", "list", "-l", name], 'r') do |io|
+    # this regex is using lookahead/behind to match things within \( and \), non-greedily.
+    io.readlines.grep(/^#{name}\s/).first[/(?<=\().*?(?=\))/].split(', ').first
+  end
+end
+
+def filtered_project_files()
+  Dir.chdir __dir__ do
+    Find.find(".").reject {|f|
+      !File.file?(f) ||
+       f =~ %r{^\./(.git|tmp)} ||
+       f =~ %r{\.(so|gem)$}
+    }.map {|f| f.sub %r{^\./}, '' }
+  end
+end
+
+adoc = Asciidoctor.load_file("README.adoc")
+summary = adoc.sections.find {|s| s.name == "Description" }.blocks[0].content.gsub(/\n/, ' ')
+description = adoc.sections.find {|s| s.name == "Description" }.blocks[1].content.gsub(/\n/, ' ')
+config = YAML.load_file(File.join(__dir__, "project.yaml"))
+project = config.fetch('name', File.split(File.expand_path(__dir__)).last)
+toplevel_module = config.fetch('toplevel_module') { project.capitalize }
+version = adoc.attributes['revnumber']
+dependencies = config.fetch('dependencies', {})
+if dependencies.nil?
+  dependencies = {}
+end
+dev_dependencies = config.fetch('dev-dependencies', {})
+if dev_dependencies.nil?
+  dev_dependencies = {}
+end
+license = config.fetch('license') { "LGPL-3.0" }
+
+#["rake", "asciidoctor", "yard", "pry", "rspec", "rspec-sequel-formatter", "#{project}-tests"]
+["rake", "asciidoctor", "yard", "pry"].each do |dep|
+  dev_dependencies[dep] = dev_dependencies.fetch(dep) {|d| "=#{installed_gem_version(d)}" }
+end
+
+gemspec_template = <<GEMSPEC
+Gem::Specification.new do |s|
+  s.name        = "<%= project %>"
+  s.version     = "<%= version %>"
+  s.licenses    = ["<%= license %>"]
+  s.platform    = Gem::Platform::RUBY
+  s.summary     = "<%= summary %>"
+  s.description = "<%= description %>"
+  s.authors     = ["<%= adoc.author %>"]
+  s.email       = "<%= adoc.attributes['email'] %>"
+  s.date        = "<%= Date.today %>"
+  s.files       = [<%= all_files.map{|f| '"' + f + '"' }.join(",\n                   ") %>]
+  s.homepage    = "<%= adoc.attributes['homepage'] %>"
+
+% dependencies.each_pair do |req, vers|
+  s.add_dependency "<%= req %>", "<%= vers %>"
+% end
+
+% dev_dependencies.each_pair do |req, vers|
+  s.add_development_dependency "<%= req %>", "<%= vers %>"
+% end
+end
+GEMSPEC
+
+task default: ["lib/riemann-ruby-experiments/riemann.pb.rb",
+               :gen_version, :gemspec, :gemfile, :build]
+
+task "lib/riemann-ruby-experiments/riemann.pb.rb" do
+  sh "ruby-protoc", "data/riemann.proto"
+  mv "data/riemann.pb.rb", "lib/riemann-ruby-experiments/riemann.pb.rb"
+end
+
+task :gen_version do
+  File.open(File.join("lib", project, "version.rb"), 'w') {|f|
+    f.puts "module #{toplevel_module}"
+    major, minor, tiny = *version.split(/\./).map {|p| p.to_i }
+    f.puts '  VERSION = "' + version + '"'
+    f.puts "  VERSION_MAJOR = #{major}"
+    f.puts "  VERSION_MINOR = #{minor}"
+    f.puts "  VERSION_TINY = #{tiny}"
+    f.puts "end"
+  }
+end
+
+task :gemspec => [:gen_version] do
+  files_in_git = IO.popen(["git", "ls-files"], 'r') { |io| io.readlines.map {|l| l.chomp } }
+  all_files = filtered_project_files()
+  if all_files - files_in_git
+    puts "Looks like there's some files uncommitted."
+  end
+
+  requires = all_files.grep(/\.rb$/).
+                           map {|f| File.readlines(f).grep (/^\s*require(?!_relative)\b/) }.
+                           flatten.
+                           map {|line| line.split(/['"]/).at(1).split('/').at(0) }.
+                           uniq
+
+  missing_deps = requires - dependencies.keys
+  if missing_deps.length > 0
+    puts "There may be some dependencies not listed for the gemspec:"
+    puts missing_deps.join(", ")
+  end
+
+  File.open(project + ".gemspec", 'w') do |f|
+    erb = ERB.new(gemspec_template, nil, "%<>")
+    f.write(erb.result(binding))
+  end
+end
+
+task :gemfile do
+  File.open("Gemfile", 'w') do |f|
+    f.puts "source 'https://rubygems.org"
+    f.puts "gemspec"
+  end
+end
+
+task :build => [:gemspec] do
+  system "gem build #{project}.gemspec"
+end
+
+task :install => [:build] do
+  system "gem install ./#{project}-#{version}.gem"
+end
+
+task :clean do
+  rm_f "./#{project}-#{version}.gem"
+  rm_rf "tmp"
+end

data/data/riemann.proto

@@ -0,0 +1,43 @@
+message State {
+  optional int64 time = 1;
+  optional string state = 2;
+  optional string service = 3;
+  optional string host = 4;
+  optional string description = 5;
+  optional bool once = 6;
+  repeated string tags = 7;
+  optional float ttl = 8;
+  optional float metric_f = 15;
+}
+
+message Event {
+  optional int64 time = 1;
+  optional string state = 2;
+  optional string service = 3;
+  optional string host = 4;
+  optional string description = 5;
+  repeated string tags = 7;
+  optional float ttl = 8;
+  repeated Attribute attributes = 9;
+
+  optional sint64 metric_sint64 = 13;
+  optional double metric_d = 14;
+  optional float metric_f = 15;
+}
+
+message Query {
+  optional string string = 1;
+}
+
+message Msg {
+  optional bool ok = 2;
+  optional string error = 3;
+  repeated State states = 4;
+  optional Query query = 5;
+  repeated Event events = 6;
+}
+
+message Attribute {
+  required string key = 1;
+  optional string value = 2;
+}

data/lib/riemann-ruby-experiments.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+#
+require "protocol_buffers"
+require "net/tcp_client"
+require "English"
+require 'set'
+require 'date'
+
+module Riemann
+end
+
+require_relative 'riemann-ruby-experiments/riemann.pb'
+require_relative 'riemann-ruby-experiments/event.rb'
+require_relative 'riemann-ruby-experiments/main'
+
+# I do a lot of testing with pry.
+if $0 == __FILE__
+  require 'pry'
+  c = Riemann::Experiment::Client.new()
+  binding.pry
+end

data/lib/riemann-ruby-experiments/event.rb

@@ -0,0 +1,205 @@
+module Riemann::Experiment
+  class Event
+    attr_accessor :attribute_names
+    attr_accessor :protobuf
+
+    # Provide defaults on initialization
+    def initialize()
+      @attrs = []
+      @cached_attrs = {}
+    end
+
+    def setup(client)
+      @service = client&.default_service
+      @host = client&.default_host
+      @tags = client&.default_tags
+      @ttl = client&.default_ttl
+      @protobuf = ::Event.new
+    end
+
+    def build(**fields)
+      fields.each_pair {|k, v|
+        self.send("#{k}=".to_sym, v)
+      }
+    end
+
+    def self.load(pb)
+      e = self.new()
+      if !pb.is_a?(::Event)
+        raise ArgumentError, "Not an Event protocol buffer object"
+      end
+      e.protobuf = pb
+      pb.attributes.each {|a|
+        e.attribute_set(a.key, a.value)
+      }
+      e
+    end
+
+    def attribute_set(name, value)
+      if attribute_get_value(name)
+        a = protobuf.attributes&.detect {|a| a.key == name }
+        a.value = value
+      else
+        a = Attribute.new
+        a.key = name
+        a.value = value
+        protobuf.attributes << a
+      end
+      @cached_attrs[name] = value
+    end
+
+    def attribute_get_value(name)
+      @cached_attrs.fetch(name) {
+        a = protobuf.attributes&.detect {|a| a.key == name }
+        if !a.nil?
+          @cached_attrs[name] = a.value
+          retval = a.value
+        else
+          retval = yield(name) if block_given?
+        end
+        retval
+      }
+    end
+
+    def each_attribute
+      return enum_for(:each_attribute) unless block_given?
+      protobuf.attributes.each {|a|
+        yield(a.key, a.value)
+      }
+    end
+
+    def time=(time)
+      case time
+      when ::Time
+        protobuf.time = time.to_i
+      when ::DateTime
+        protobuf.time = time.to_time.to_i
+      else
+        protobuf.time = time
+      end
+    end
+
+    def time
+      Time.at(protobuf.time)
+    end
+
+    def service=(service)
+      protobuf.service = service.to_s
+    end
+
+    def service
+      s = protobuf.service
+      (s != "") ? s : nil
+    end
+
+    def state=(s)
+      protobuf.state = s
+    end
+
+    def state
+      s = protobuf.state
+      (s != "") ? s : nil
+    end
+
+    def host=(host)
+      protobuf.host = host.to_s
+    end
+
+    def host
+      h = protobuf.host
+      h != "" ? h : nil
+    end
+
+    def description=(d)
+      protobuf.description = d.to_s
+    end
+
+    def description
+      d = protobuf.description
+      d != "" ? d : nil
+    end
+
+    def ttl=(ttl)
+      protobuf.ttl = ttl.to_f
+    end
+
+    def ttl
+      t = protobuf.ttl
+      t != "" ? t : nil
+    end
+
+    def add_tags(*tags)
+      @tags = [] if @tags.nil?
+      tags.each {|t| @tags.push(t.to_s) }
+    end
+
+    def tags
+      protobuf.tags
+    end
+
+    def metric=(m)
+      case m
+      when Integer
+        protobuf.metric_sint64 = m
+      when Float
+        protobuf.metric_d = m
+      end  # BigDecimal? Anything else?
+    end
+
+    def metric
+      protobuf.metric_sint64 || protobuf.metric_d || protobuf.metric_f
+    end
+
+    def maybe_apply_defaults
+      if protobuf.service == ""
+        @service ||= "#{$0};#{$PID}"
+        protobuf.service = @service
+      end
+      if protobuf.host == ""
+        protobuf.host = @host
+      end
+
+      if !@tags.nil?
+        protobuf.tags = @tags
+      end
+      if !@ttl.nil?
+        protobuf.ttl = @ttl
+      end
+    end
+
+    def to_s
+      maybe_apply_defaults
+      protobuf.to_s
+    end
+
+    alias_method :to_sym, :to_s
+    alias_method :dump, :to_s
+
+    def respond_to?(m, include_private = false)
+      ms = m.to_s
+      mnoeq = ms[0..-2]
+      if ms.end_with?("=") && ms.length >= 2
+        true
+      elsif attribute_get_value(ms)
+        true
+      else
+        super
+      end
+    end
+
+    def method_missing(m, *rest, &blk)
+      ms = m.to_s
+      if ms.end_with?("=") && ms.length >= 2
+        attribute_set(ms[0..-2], rest.first.to_s)
+      else
+        val = attribute_get_value(ms)
+        if val.nil?
+          super
+        else
+          val
+        end
+      end
+    end
+  end
+end
+ 

data/lib/riemann-ruby-experiments/main.rb

@@ -0,0 +1,117 @@
+module Riemann::Experiment
+  class Client < Net::TCPClient
+    attr_reader :keepalive_active, :keepalive_idle, :keepalive_interval, :keepalive_count
+    attr_accessor :default_host, :default_service, :default_tags, :default_ttl, :pending_events
+
+    # service and host can be assigned to :default here,
+    # to use a string generated from process info and hostname, respectively.
+    def initialize(options = {})
+      @event_fields = Set.new([:time, :service, :host, :description, :metric, :tags, :ttl])
+      @msg_fields = Set.new([:ok, :error, :states, :query, :events])
+      @generated_service = "#{$0};#{$PID}"
+
+      default_opts = {server: "localhost:5555",
+                      connect_timeout: 2,
+                      read_timeout: 2,
+                      write_timeout: 2 }
+
+      @default_service = options.delete(:service)
+      @default_host = options.delete(:host) || Socket.gethostname
+      @default_tags = options.delete(:tags)
+      @default_ttl = options.delete(:ttl)
+      @pending_events = []
+
+      @keepalive_active = options.delete(:keepalive_active) || true
+      @keepalive_idle   = options.delete(:keepalive_idle) || 60
+      @keepalive_interval = options.delete(:keepalive_interval) || 30
+      @keepalive_count = options.delete(:keepalive_count) || 5
+
+      options = default_opts.merge(options)
+      options.delete(:buffered)
+      options[:buffered] = false
+      super(options)
+      setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE,  @keepalive_active)
+      setsockopt(::Socket::SOL_TCP,    ::Socket::TCP_KEEPIDLE , @keepalive_idle)
+      setsockopt(::Socket::SOL_TCP,    ::Socket::TCP_KEEPINTVL, @keepalive_interval)
+      setsockopt(::Socket::SOL_TCP,    ::Socket::TCP_KEEPCNT  , @keepalive_count)
+    end
+
+    def add_event(*rest)
+      e = Riemann::Experiment::Event.new()
+      e.setup(self)
+      e.time = Time.now.to_i
+      e.build(*rest)
+      @pending_events.push(e)
+    end
+
+    def send_message(**p)
+      m = ::Msg.new
+      if p[:ok] == true
+        m.ok = true
+      elsif p[:ok] == false
+        m.ok = false
+      end
+      m.error = p[:error] if p.has_key?(:error)
+      if p.has_key?(:query)
+        q = Query.new
+        q.string = p[:query]
+        m.query = q
+      end
+      @pending_events.each {|e|
+        e.maybe_apply_defaults
+        m.events << e.protobuf
+      }
+      r = exchange(m.to_s)
+      @pending_events = []
+      r
+    end
+
+    # Query the riemann server for events.
+    # Skips the queue of otherwise pending events.
+    def [](querystring)
+      m = Msg.new
+      q = Query.new
+      q.string = querystring
+      m.query = q
+      r = exchange(m.to_s)
+      if !r.nil? && r.ok == true
+        r.events.map {|e| Riemann::Experiment::Event.load(e) }
+      else
+        []
+      end
+    end
+
+    # Writes a riemann message to socket.
+    # You probably want to use exchange, because it receives a 
+    # response from 
+    # yields to a block if the write times out (and re-raises the WriteTimeout)
+    def put(message)
+      msg = message.to_s
+      out_packet = [msg.length].pack('N') + msg
+      write(out_packet)
+    rescue Net::TCPClient::WriteTimeout => e
+      yield if block_given?
+      raise e
+    end
+
+    # Receives a response from a riemann server.
+    # This method will raise ProtocolBuffers::DecoderError on invalid data.
+    # yields to a block if the read times out (and re-raises the ReadTimeout)
+    def get()
+      in_len = read(4).unpack("N").first
+      in_packet = read(in_len)
+      Msg.parse(in_packet)
+    rescue Net::TCPClient::ReadTimeout => e
+      yield if block_given?
+      raise e
+    end
+
+    def exchange(message)
+      retry_on_connection_failure do
+        put(message)
+        get
+      end
+    end
+  end
+end
+

data/lib/riemann-ruby-experiments/riemann.pb.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+# Generated by the protocol buffer compiler. DO NOT EDIT!
+
+require 'protocol_buffers'
+
+# forward declarations
+class State < ::ProtocolBuffers::Message; end
+class Event < ::ProtocolBuffers::Message; end
+class Query < ::ProtocolBuffers::Message; end
+class Msg < ::ProtocolBuffers::Message; end
+class Attribute < ::ProtocolBuffers::Message; end
+
+class State < ::ProtocolBuffers::Message
+  set_fully_qualified_name "State"
+
+  optional :int64, :time, 1
+  optional :string, :state, 2
+  optional :string, :service, 3
+  optional :string, :host, 4
+  optional :string, :description, 5
+  optional :bool, :once, 6
+  repeated :string, :tags, 7
+  optional :float, :ttl, 8
+  optional :float, :metric_f, 15
+end
+
+class Event < ::ProtocolBuffers::Message
+  set_fully_qualified_name "Event"
+
+  optional :int64, :time, 1
+  optional :string, :state, 2
+  optional :string, :service, 3
+  optional :string, :host, 4
+  optional :string, :description, 5
+  repeated :string, :tags, 7
+  optional :float, :ttl, 8
+  repeated ::Attribute, :attributes, 9
+  optional :sint64, :metric_sint64, 13
+  optional :double, :metric_d, 14
+  optional :float, :metric_f, 15
+end
+
+class Query < ::ProtocolBuffers::Message
+  set_fully_qualified_name "Query"
+
+  optional :string, :string, 1
+end
+
+class Msg < ::ProtocolBuffers::Message
+  set_fully_qualified_name "Msg"
+
+  optional :bool, :ok, 2
+  optional :string, :error, 3
+  repeated ::State, :states, 4
+  optional ::Query, :query, 5
+  repeated ::Event, :events, 6
+end
+
+class Attribute < ::ProtocolBuffers::Message
+  set_fully_qualified_name "Attribute"
+
+  required :string, :key, 1
+  optional :string, :value, 2
+end
+

data/lib/riemann-ruby-experiments/version.rb

@@ -0,0 +1,6 @@
+module Riemann::Experiments
+  VERSION = "0.0.3"
+  VERSION_MAJOR = 0
+  VERSION_MINOR = 0
+  VERSION_TINY = 3
+end

data/project.yaml

@@ -0,0 +1,11 @@
+---
+name: riemann-ruby-experiments
+toplevel_module: Riemann::Experiments
+dependencies:
+  ruby-protocol-buffers: ">= 1.6.1"
+  net_tcp_client: ">= 2.0.0"
+dev_dependencies:
+  rake: ">=10.3"
+  yard: "~> 0.8.7"
+  asciidoctor: "~> 1.5.2"
+

data/riemann-ruby-experiments.gemspec

@@ -0,0 +1,31 @@
+Gem::Specification.new do |s|
+  s.name        = "riemann-ruby-experiments"
+  s.version     = "0.0.3"
+  s.licenses    = ["LGPL-3.0"]
+  s.platform    = Gem::Platform::RUBY
+  s.summary     = "A Riemann client for ruby"
+  s.description = "Just another client, to experiment with."
+  s.authors     = ["Chris Riddoch"]
+  s.email       = "riddochc@gmail.com"
+  s.date        = "2016-05-30"
+  s.files       = ["Gemfile",
+                   "README.adoc",
+                   "Rakefile",
+                   "data/riemann.proto",
+                   "lib/riemann-ruby-experiments/event.rb",
+                   "lib/riemann-ruby-experiments/main.rb",
+                   "lib/riemann-ruby-experiments/riemann.pb.rb",
+                   "lib/riemann-ruby-experiments/version.rb",
+                   "lib/riemann-ruby-experiments.rb",
+                   "project.yaml",
+                   "riemann-ruby-experiments.gemspec"]
+  s.homepage    = "https://syntacticsugar.org/projects/riemann-ruby-experiments"
+
+  s.add_dependency "ruby-protocol-buffers", ">= 1.6.1"
+  s.add_dependency "net_tcp_client", ">= 2.0.0"
+
+  s.add_development_dependency "rake", "=10.5.0"
+  s.add_development_dependency "asciidoctor", "=1.5.5.dev"
+  s.add_development_dependency "yard", "=0.8.7.6"
+  s.add_development_dependency "pry", "=0.10.3"
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: riemann-ruby-experiments
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Chris Riddoch
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby-protocol-buffers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+- !ruby/object:Gem::Dependency
+  name: net_tcp_client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 10.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 10.5.0
+- !ruby/object:Gem::Dependency
+  name: asciidoctor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.5.5.dev
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.5.5.dev
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.7.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.7.6
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.10.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.10.3
+description: Just another client, to experiment with.
+email: riddochc@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.adoc
+- Rakefile
+- data/riemann.proto
+- lib/riemann-ruby-experiments.rb
+- lib/riemann-ruby-experiments/event.rb
+- lib/riemann-ruby-experiments/main.rb
+- lib/riemann-ruby-experiments/riemann.pb.rb
+- lib/riemann-ruby-experiments/version.rb
+- project.yaml
+- riemann-ruby-experiments.gemspec
+homepage: https://syntacticsugar.org/projects/riemann-ruby-experiments
+licenses:
+- LGPL-3.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A Riemann client for ruby
+test_files: []
+has_rdoc: