appdash 0.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 832463798ecc366655cfe139b52dfdab61e4ad14
+  data.tar.gz: f5b7db5b952464cfe30f1aa93c673bb4252d2a9d
+SHA512:
+  metadata.gz: 87131161bf4489115b1b559e342180e4538e9e48363e314ff9e947b393ccf8592bff625a7022d168ba7fb94f19f2786eb52451d63b4b01734f95aa192f41aee9
+  data.tar.gz: 04963a82c52bedb5fbd7a5b93feca849c0494b95b98e9a5264126ad2529339110b0eddc73622c9db5b33aeb12c0d483f1d342cb7c905e6772583c86e27eb1f2d

data/.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,57 @@
+PATH
+  remote: .
+  specs:
+    appdash (0.6.0)
+      protobuf
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (4.2.5)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    diff-lcs (1.2.5)
+    i18n (0.7.0)
+    json (1.8.3)
+    middleware (0.1.0)
+    minitest (5.8.3)
+    protobuf (3.5.5)
+      activesupport (>= 3.2)
+      middleware
+      thor
+      thread_safe
+    rack (1.6.4)
+    rake (10.4.2)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.1)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    thor (0.19.1)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  appdash!
+  bundler
+  rack
+  rake
+  rspec
+
+BUNDLED WITH
+   1.10.6

data/MIT-LICENCE

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Black Square Media
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,35 @@
+Ruby Appdash
+============
+
+[Appdash](https://github.com/sourcegraph/appdash) client for Ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'appdash'
+
+Or install:
+
+    $ gem install appdash
+
+Connect to an instance:
+
+    client = Appdash::Client.new host: "remote.host", port: 7701, max_buffer_size: 20
+
+Collect spans:
+
+    client.span do |s|
+      s.name "Request"
+      s.log "a log entry with a timestamp"
+    end
+
+For full options and event types, please see the [Documentation](http://www.rubydoc.info/gems/appdash).
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Make a pull request

data/Rakefile

@@ -0,0 +1,28 @@
+require 'rake'
+require 'bundler/gem_tasks'
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec
+
+namespace :protobuf do
+  PROTO_ROOT = "./defs/appdash"
+
+  task :fetch do
+    target = "#{PROTO_ROOT}/collector.proto"
+    sh %(mkdir -p #{PROTO_ROOT})
+    sh %(curl -sSL https://raw.githubusercontent.com/sourcegraph/appdash/master/internal/wire/collector.proto | sed 's/package wire/package appdash/' > #{target})
+  end
+
+  task :compile do
+    Dir[PROTO_ROOT+"/**/*.proto"].each do |file|
+      sh "PB_NO_TAG_WARNINGS=1 protoc -I ./defs --ruby_out ./lib #{file}"
+    end
+  end
+
+  desc "Rebuild protobuf definitions"
+  task rebuild: [:fetch, :compile]
+
+end

data/appdash.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name          = "appdash"
+  s.version       = "0.6.0"
+  s.authors       = ["Black Square Media"]
+  s.email         = ["dimitrij@blacksquaremedia.com"]
+  s.summary       = %q{Appdash client for ruby}
+  s.description   = %q{Ruby client for Appdash, Sourcegraph's application tracing system, based on Google's Dapper}
+  s.homepage      = "https://github.com/bsm/appdash-rb"
+  s.required_ruby_version = '>= 1.9.0'
+
+  s.files         = `git ls-files`.split($/)
+  s.test_files    = s.files.grep(%r{^(spec)/})
+  s.require_paths = ["lib"]
+
+  s.add_dependency(%q<protobuf>)
+
+  s.add_development_dependency(%q<rake>)
+  s.add_development_dependency(%q<rack>)
+  s.add_development_dependency(%q<bundler>)
+  s.add_development_dependency(%q<rspec>)
+end

data/defs/appdash/collector.proto

@@ -0,0 +1,30 @@
+package appdash;
+
+// CollectPacket is the message sent to a remote collector server by one of
+// it's clients.
+message CollectPacket {
+	// SpanID is the group of information which can uniquely identify the exact
+	// span being collected.
+	required group SpanID = 1 {
+		// trace is the root ID of the tree that contains all of the spans
+		// related to this one.
+		required fixed64 trace = 2;
+
+		// span is an ID that probabilistically uniquely identifies this span.
+		required fixed64 span = 3;
+
+		// parent is the ID of the parent span, if any.
+		optional fixed64 parent = 4;
+	}
+
+	// Annotation is any number of annotations for the span to be collected.
+	repeated group Annotation = 5 {
+		// key is the annotation's key.
+		required string key = 6;
+
+		// value is the annotation's value, which may be either human or
+		// machine readable, depending on the schema of the event that
+		// generated it.
+		optional bytes value = 7;
+	}
+}

data/lib/appdash.rb

@@ -0,0 +1,4 @@
+require 'appdash/wire'
+require 'appdash/span'
+require 'appdash/events'
+require 'appdash/client'

data/lib/appdash/client.rb

@@ -0,0 +1,77 @@
+require 'socket'
+require 'thread'
+
+module Appdash
+  class Client
+
+    # Client defaults
+    DEFAULTS = {
+      host: 'localhost',
+      port: 7701,
+      max_buffer_size: 1,
+    }.freeze
+
+    # Initializes a new client
+    # @param [Hash] opts
+    # @option opts [String] :host the hostname, defaults to localhost
+    # @option opts [Integer] :port the port, defaults to 7701
+    # @option opts [Integer] :max_buffer_size number of spans in the buffer before flushing, defaults to 1 (= no buffering)
+    def initialize(opts = {})
+      @config = DEFAULTS.merge(opts)
+      @sock   = TCPSocket.new @config[:host], @config[:port]
+      @buffer = []
+      @mutex  = Mutex.new
+    end
+
+    # Traces a new span with a series of associated events. Accepts an optional block. If no block is given you must flush
+    # to send data to the collector.
+    #
+    # @example manual flush
+    #
+    #   span = client.span
+    #   span.name "Request"
+    #   span.message "A simple message"
+    #   span.flush
+    #
+    # @example with block
+    #
+    #   client.span do |span|
+    #     span.name "Request"
+    #     span.message "A simple message"
+    #   end
+    def span(&block)
+      span = Appdash::Span.new(self)
+      return span unless block
+
+      begin
+        block.call(span)
+      ensure
+        span.flush
+      end
+    end
+
+    # Shutdown flushes any remaining buffered packets and closes the connection
+    def shutdown
+      flush_buffer!
+      @sock.shutdown
+    end
+
+    private
+
+      def write(packets)
+        packets.each do |packet|
+          raw = Protobuf::Field::VarintField.encode(packet.bytesize)+packet
+          @buffer.push(raw)
+        end
+        flush_buffer! unless @buffer.size < @config[:max_buffer_size]
+      end
+
+      def flush_buffer!
+        @mutex.synchronize do
+          @sock.write @buffer.join("\n") unless @buffer.empty?
+          @buffer.clear
+        end
+      end
+
+  end
+end

data/lib/appdash/collector.pb.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+##
+# This file is auto-generated. DO NOT EDIT!
+#
+require 'protobuf/message'
+
+module Appdash
+
+  ##
+  # Message Classes
+  #
+  class CollectPacket < ::Protobuf::Message
+    class SpanID < ::Protobuf::Message; end
+    class Annotation < ::Protobuf::Message; end
+
+  end
+
+
+
+  ##
+  # Message Fields
+  #
+  class CollectPacket
+    class SpanID
+      required :fixed64, :trace, 2
+      required :fixed64, :span, 3
+      optional :fixed64, :parent, 4
+    end
+
+    class Annotation
+      required :string, :key, 6
+      optional :bytes, :value, 7
+    end
+
+    required ::Appdash::CollectPacket::SpanID, :spanid, 1
+    repeated ::Appdash::CollectPacket::Annotation, :annotation, 5
+  end
+
+end
+

data/lib/appdash/event/base.rb

@@ -0,0 +1,62 @@
+require 'appdash/wire'
+
+module Appdash
+  module Event
+
+    # Base forms the most basic event type
+    class Base
+
+      attr_reader :schema, :attrs
+
+      # @param [String] schema the event schema name
+      # @param [Hash] attrs event attributes
+      def initialize(schema, attrs = {})
+        super()
+        @schema = schema
+        @attrs = attrs
+      end
+
+      # @return [Array<Appdash::CollectPacket::Annotation>] marshalable annotations
+      def to_a
+        annotate(attrs) + [annotation(['_schema', schema].join(':'))]
+      end
+
+      protected
+
+        def annotate(hash, prefix = nil)
+          hash.map do |key, value|
+            key = [prefix, normalize(key)].compact.join('.')
+
+            case value
+            when Hash
+              annotate(value, key)
+            else
+              annotation(key, value)
+            end
+          end.flatten
+        end
+
+        def annotation(key, value = nil)
+          case value
+          when DateTime, Time
+            value = value.strftime('%FT%T%:z')
+          when NilClass
+            # ignore
+          else
+            value = value.to_s
+          end
+          Appdash::CollectPacket::Annotation.new(key: key, value: value)
+        end
+
+        def normalize(key)
+          key = key.to_s
+          key = key.sub(/^[a-z\d]*/) { Appdash::Event.acronyms[$&] || $&.capitalize }
+          key.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{Appdash::Event.acronyms[$2] || $2.capitalize}" }
+
+          key[0] = key[0].upcase if key.size > 0
+          key
+        end
+
+    end
+  end
+end

data/lib/appdash/event/log.rb

@@ -0,0 +1,17 @@
+require 'appdash/event/base'
+require 'time'
+
+module Appdash
+  module Event
+
+    # Log is an event whose timestamp is the current time and contains the given human-readable log message.
+    class Log < Base
+
+      # @param [String] msg the log message
+      def initialize(msg)
+        super("log", msg: msg, time: Time.now)
+      end
+
+    end
+  end
+end

data/lib/appdash/event/message.rb

@@ -0,0 +1,16 @@
+require 'appdash/event/base'
+
+module Appdash
+  module Event
+
+    # Message is an event that contains only a human-readable message.
+    class Message < Base
+
+      # @param [String] msg the message
+      def initialize(msg)
+        super("msg", msg: msg)
+      end
+
+    end
+  end
+end

data/lib/appdash/event/rack_server.rb

@@ -0,0 +1,54 @@
+require 'appdash/event/base'
+
+module Appdash
+  module Event
+
+    # RackServer represents a HTTP event where a client's request was served via Rack.
+    class RackServer < Appdash::Event::Base
+
+      # @param [Rack::Request] req a Rack request object
+      # @param [Rack::Response] resp an optional Rack response object
+      # @param [Hash] attrs additional attributes, e.g. :user or :route
+      def initialize(req, resp = nil, attrs = {})
+        server = attrs.dup
+        server[:send] ||= Time.now
+        server[:request] ||= {}
+        server[:request].update parse_request(req)
+        if resp
+          server[:response] ||= {}
+          server[:response].update parse_response(resp)
+        end
+
+        super("HTTPServer", server: server)
+      end
+
+      protected
+
+        def parse_request(req)
+          data = {
+            method: req.request_method,
+            url: req.url,
+            scheme: req.scheme,
+            host: req.host,
+            remote_ip: req.ip,
+            content_length: req.content_length
+          }
+
+          [:content_type, :user_agent].each do |name|
+            value = req.send(name)
+            data[name] = value if value
+          end
+
+          data
+        end
+
+        def parse_response(resp)
+          {
+            content_length: resp.length,
+            status_code: resp.status
+          }
+        end
+
+    end
+  end
+end

data/lib/appdash/event/span_name.rb

@@ -0,0 +1,16 @@
+require 'appdash/event/base'
+
+module Appdash
+  module Event
+
+    # SpanName is an event which sets a span's name.
+    class SpanName < Base
+
+      # @param [String] name the event span name
+      def initialize(name)
+        super("name", name: name)
+      end
+
+    end
+  end
+end

data/lib/appdash/events.rb

@@ -0,0 +1,21 @@
+require 'appdash/event/base'
+require 'appdash/event/span_name'
+require 'appdash/event/message'
+require 'appdash/event/log'
+require 'appdash/event/rack_server'
+
+module Appdash
+  module Event
+
+    # @return [Hash] known acronyms for attribute translations
+    def self.acronyms
+      @acronyms ||= {
+        "url" => "URL",
+        "uri" => "URI",
+        "id"  => "ID",
+        "ip"  => "IP",
+      }
+    end
+
+  end
+end

data/lib/appdash/span.rb

@@ -0,0 +1,48 @@
+require 'appdash/span/id'
+
+module Appdash
+  class Span
+
+    # @attr_reader :root_id returns the root span ID
+    attr_reader :root_id
+
+    # @attr_reader :id returns the current span ID
+    attr_reader :id
+
+    def initialize(client)
+      @client  = client
+      @packets = []
+      @root_id = Appdash::Span::ID.new
+      @id      = root_id
+    end
+
+    # Appends a new Appdash::Event::SpanName event
+    def name(val)
+      event Appdash::Event::SpanName.new(val)
+    end
+
+    # Appends a new Appdash::Event::Message event
+    def message(msg)
+      event Appdash::Event::Message.new(msg)
+    end
+
+    # Appends a new Appdash::Event::Log event
+    def log(msg)
+      event Appdash::Event::Log.new(msg)
+    end
+
+    # Appends a generic Appdash::Event event
+    def event(evt)
+      @packets.push Appdash::CollectPacket.encode(evt, @id)
+      @id = @id.child
+    end
+
+    def flush
+      count = @packets.size
+      @client.send :write, @packets
+      @packets.clear
+      count
+    end
+
+  end
+end

data/lib/appdash/span/id.rb

@@ -0,0 +1,44 @@
+require 'securerandom'
+
+module Appdash
+  class Span
+
+    class ID
+      # @attr_reader [Integer] root ID of the tree that contains all of the spans related to this one.
+      attr_reader :trace
+
+      # @attr_reader [Integer] an ID that probabilistically uniquely identifies this span.
+      attr_reader :span
+
+      # @attr_reader [Integer] the ID of the parent span, if any.
+      attr_reader :parent
+
+      # Creates a new root span
+      # @param [Appdash::SpanID] parent, optional parent
+      def initialize(parent = nil)
+        @trace  = parent ? parent.trace : random_uint64
+        @span   = random_uint64
+        @parent = parent.span if parent
+      end
+
+      # @return [Appdash::SpanID] creates a child span
+      def child
+        self.class.new(self)
+      end
+
+      # @return [String] string ID
+      def to_s
+        [trace, span, parent].compact.map do |num|
+          num.to_s(16).rjust(16, '0')
+        end.join("/")
+      end
+
+      private
+
+        def random_uint64
+          SecureRandom.random_bytes(8).unpack("Q")[0]
+        end
+
+    end
+  end
+end

data/lib/appdash/wire.rb

@@ -0,0 +1,13 @@
+require 'protobuf'
+require 'appdash/collector.pb.rb'
+
+module Appdash
+  class CollectPacket
+
+    def self.encode(event, id)
+      wired = SpanID.new(trace: id.trace, span: id.span, parent: id.parent)
+      new(spanid: wired, annotation: event.to_a).encode
+    end
+
+  end
+end

data/spec/appdash/client_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+RSpec.describe Appdash::Client do
+
+  let(:mock_socket) { double("TCPSocket", shutdown: nil) }
+  before  { allow(TCPSocket).to receive(:new).and_return(mock_socket) }
+
+  it "should collect spans" do
+    span = subject.span
+    span.event(Appdash::Event::Message.new("Hello world!"))
+
+    expect(mock_socket).to receive(:write) do |raw|
+      expect(raw.bytesize).to eq(57)
+      expect(raw.bytes.first).to eq(56)
+    end.and_return(57)
+    span.flush
+  end
+
+  it "should support buffering" do
+    subject = described_class.new(max_buffer_size: 3)
+    subject.span do |s|
+      s.message("Message A")
+      s.message("Message B")
+    end
+
+    expect(mock_socket).to receive(:write) do |raw|
+      expect(raw.bytesize).to eq(118)
+    end
+    subject.shutdown
+  end
+
+end

data/spec/appdash/event/base_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+RSpec.describe Appdash::Event::Base do
+
+  subject { described_class.new 'test', name: "Query", some_other: 2, sub: { req_url: "http://example.com/path", nest: { v: Time.utc(2015) }}}
+
+  it "should init" do
+    expect(subject.schema).to eq("test")
+    expect(subject.attrs.size).to eq(3)
+  end
+
+  it "should annotate" do
+    expect(atoh(subject.to_a)).to eq(
+      "Name" => "Query",
+      "SomeOther" => "2",
+      "Sub.ReqURL" => "http://example.com/path",
+      "Sub.Nest.V"=>"2015-01-01T00:00:00+00:00",
+      "_schema:test"=>"",
+    )
+  end
+
+end

data/spec/appdash/event/log_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+RSpec.describe Appdash::Event::Log do
+
+  let(:time) { Time.utc(2001,2,3,4,5,6) }
+  before     { allow(Time).to receive(:now).and_return(time) }
+  subject    { described_class.new "Hi" }
+
+  it "should init" do
+    expect(subject.schema).to eq("log")
+    expect(subject.attrs).to eq(msg: "Hi", time: time)
+  end
+
+  it "should annotate" do
+    expect(atoh(subject.to_a)).to eq(
+      "Msg" => "Hi",
+      "Time" => "2001-02-03T04:05:06+00:00",
+      "_schema:log" => "",
+    )
+  end
+
+end

data/spec/appdash/event/message_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+RSpec.describe Appdash::Event::Message do
+
+  subject { described_class.new "Hi" }
+
+  it "should init" do
+    expect(subject.schema).to eq("msg")
+    expect(subject.attrs).to eq(msg: "Hi")
+  end
+
+  it "should annotate" do
+    expect(atoh(subject.to_a)).to eq("Msg"=>"Hi", "_schema:msg"=>"")
+  end
+
+end

data/spec/appdash/event/rack_server_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+RSpec.describe Appdash::Event::RackServer do
+
+  let(:time)     { Time.utc(2001,2,3,4,5,6) }
+  let(:response) { Rack::Response.new([], 201, 'Content-Length' => 33) }
+  let(:request) do
+    env = Rack::MockRequest.env_for("http://example.com:8080/", "REMOTE_ADDR" => "10.10.10.10", 'CONTENT_LENGTH' => 12, 'HTTP_USER_AGENT' => 'Test/1.0')
+    Rack::Request.new(env)
+  end
+
+  before  { allow(Time).to receive(:now).and_return(time) }
+  subject { described_class.new request, response, route: 'createPost' }
+
+  it "should init" do
+    expect(subject.schema).to eq("HTTPServer")
+    expect(subject.attrs.size).to eq(1)
+  end
+
+  it "should annotate" do
+    expect(atoh(subject.to_a)).to eq(
+      "Server.Request.ContentLength" => "12",
+      "Server.Request.Host" => "example.com",
+      "Server.Request.Method" => "GET",
+      "Server.Request.Scheme" => "http",
+      "Server.Request.RemoteIP" => "10.10.10.10",
+      "Server.Request.URL" => "http://example.com:8080/",
+      "Server.Request.UserAgent" => "Test/1.0",
+      "Server.Response.ContentLength" => "0",
+      "Server.Response.StatusCode" => "201",
+      "Server.Route" => "createPost",
+      "Server.Send" => "2001-02-03T04:05:06+00:00",
+      "_schema:HTTPServer" => "",
+    )
+  end
+
+end

data/spec/appdash/event/span_name_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+RSpec.describe Appdash::Event::SpanName do
+
+  subject { described_class.new "Query" }
+
+  it "should init" do
+    expect(subject.schema).to eq("name")
+    expect(subject.attrs).to eq(name: "Query")
+  end
+
+  it "should annotate" do
+    expect(atoh(subject.to_a)).to eq("Name" => "Query", "_schema:name" => "")
+  end
+
+end

data/spec/appdash/span/id_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+RSpec.describe Appdash::Span::ID do
+
+  before do
+    allow(SecureRandom).to receive(:random_bytes).with(8).
+      and_return("A~CDEF~H", "xyz\x00\x00\x00\x00\x00", "^&<>^*%!", "2531afas", "*&^%$-[]")
+  end
+
+  it "should create instances" do
+    expect(subject.trace).to eq(5223689881108315713)
+    expect(subject.span).to eq(8026488)
+    expect(subject.parent).to be_nil
+    expect(subject.to_s).to eq("487e464544437e41/00000000007a7978")
+  end
+
+  it "should create children" do
+    child = subject.child
+    expect(child.trace).to eq(5223689881108315713)
+    expect(child.span).to eq(2388361761649337950)
+    expect(child.parent).to eq(8026488)
+    expect(child.to_s).to eq("487e464544437e41/21252a5e3e3c265e/00000000007a7978")
+  end
+
+end

data/spec/appdash/span_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+RSpec.describe Appdash::Span do
+
+  let(:mock_client) { double("Client", write: nil) }
+  subject { described_class.new mock_client }
+
+  it "should append events" do
+    expect(subject.id).to eq(subject.root_id)
+    subject.name("test")
+    expect(subject.id).not_to eq(subject.root_id)
+    expect(subject.id.to_s.size).to eq(50)
+
+    subject.message("test message")
+    subject.log("test log")
+    expect(subject.instance_variable_get(:@packets).size).to eq(3)
+  end
+
+  it "should flush" do
+    expect(subject.flush).to eq(0)
+
+    subject.name("test")
+    subject.message("test message")
+
+    expect(mock_client).to receive(:write) do |packets|
+      expect(packets.size).to eq(2)
+      expect(packets[0].bytesize).to eq(50)
+      expect(packets[1].bytesize).to eq(65)
+    end
+    expect(subject.flush).to eq(2)
+  end
+
+end

data/spec/appdash/wire_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+RSpec.describe Appdash::CollectPacket do
+
+  it "should encode" do
+    packet = described_class.encode Appdash::Event::Message.new("Hello world!"), Appdash::Span::ID.new
+    expect(packet.bytesize).to eq(56)
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'rspec'
+require 'rack'
+require 'appdash'
+
+helpers = Module.new do
+
+  def atoh(annotations)
+    annotations.inject({}) {|h, a| h[a.key] = a.value; h }
+  end
+
+end
+
+RSpec.configure do |c|
+  c.include helpers
+end

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification
+name: appdash
+version: !ruby/object:Gem::Version
+  version: 0.6.0
+platform: ruby
+authors:
+- Black Square Media
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: protobuf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby client for Appdash, Sourcegraph's application tracing system, based
+  on Google's Dapper
+email:
+- dimitrij@blacksquaremedia.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".editorconfig"
+- Gemfile
+- Gemfile.lock
+- MIT-LICENCE
+- README.md
+- Rakefile
+- appdash.gemspec
+- defs/appdash/collector.proto
+- lib/appdash.rb
+- lib/appdash/client.rb
+- lib/appdash/collector.pb.rb
+- lib/appdash/event/base.rb
+- lib/appdash/event/log.rb
+- lib/appdash/event/message.rb
+- lib/appdash/event/rack_server.rb
+- lib/appdash/event/span_name.rb
+- lib/appdash/events.rb
+- lib/appdash/span.rb
+- lib/appdash/span/id.rb
+- lib/appdash/wire.rb
+- spec/appdash/client_spec.rb
+- spec/appdash/event/base_spec.rb
+- spec/appdash/event/log_spec.rb
+- spec/appdash/event/message_spec.rb
+- spec/appdash/event/rack_server_spec.rb
+- spec/appdash/event/span_name_spec.rb
+- spec/appdash/span/id_spec.rb
+- spec/appdash/span_spec.rb
+- spec/appdash/wire_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/bsm/appdash-rb
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Appdash client for ruby
+test_files:
+- spec/appdash/client_spec.rb
+- spec/appdash/event/base_spec.rb
+- spec/appdash/event/log_spec.rb
+- spec/appdash/event/message_spec.rb
+- spec/appdash/event/rack_server_spec.rb
+- spec/appdash/event/span_name_spec.rb
+- spec/appdash/span/id_spec.rb
+- spec/appdash/span_spec.rb
+- spec/appdash/wire_spec.rb
+- spec/spec_helper.rb