honeycomb-beeline 1.0.0.pre.alpha → 1.0.0.pre.alpha1

data/README.md

@@ -0,0 +1,37 @@
+# Honeycomb Beeline for Ruby
+
+[![Build Status](https://travis-ci.org/honeycombio/beeline-ruby.svg?branch=master)](https://travis-ci.org/honeycombio/beeline-ruby)
+[![Gem Version](https://badge.fury.io/rb/honeycomb-beeline.svg)](https://badge.fury.io/rb/honeycomb-beeline)
+
+This package makes it easy to instrument your Ruby web app to send useful events to [Honeycomb](https://www.honeycomb.io), a service for debugging your software in production.
+- [Usage and Examples](https://docs.honeycomb.io/getting-data-in/beelines/ruby-beeline/)
+
+Sign up for a [Honeycomb
+trial](https://ui.honeycomb.io/signup) to obtain an API key before starting.
+
+## Compatible with
+
+Requires Ruby version 2.2 or later
+
+Built in instrumentation for:
+
+- Active Support
+- Faraday
+- Rack
+- Rails
+- Sequel
+- Sinatra
+
+## Get in touch
+
+Please reach out to [support@honeycomb.io](mailto:support@honeycomb.io) or ping
+us with the chat bubble on [our website](https://www.honeycomb.io) for any
+assistance. We also welcome [bug reports](https://github.com/honeycombio/beeline-ruby/issues).
+
+## Contributions
+
+Features, bug fixes and other changes to `beeline-ruby` are gladly accepted. Please
+open issues or a pull request with your change. Remember to add your name to the
+CONTRIBUTORS file!
+
+All contributions will be released under the Apache License 2.0.

data/Rakefile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
+require "appraisal"
+
+RSpec::Core::RakeTask.new(:spec)
+
+RuboCop::RakeTask.new(:rubocop)
+
+task test: :spec
+
+task default: %i[rubocop test]
+
+!ENV["APPRAISAL_INITIALIZED"] && !ENV["TRAVIS"] && task(default: :appraisal)

data/UPGRADING.md

@@ -0,0 +1,82 @@
+# Upgrade Guide
+
+## 0.8.0 - 1.0.0
+
+1. If you have a web application, remove beeline configuration from the `config.ru` file
+1. If you have a rails application, run the honeycomb generator `bundle exec rails generate honeycomb {writekey}`
+1. Replace call to `Honeycomb.init` with the following (if using rails, this will now live in `config/initializers/honeycomb.rb`)
+    ```ruby
+    Honeycomb.configure do |config|
+      config.write_key = "{writekey}"
+      config.dataset = "rails"
+    end
+    ```
+1. Replace any `Rack::Honeycomb.add_field` calls with the following
+    ```ruby
+    Honeycomb.client.add_field("name", "value")
+    ```
+1. Replace any `Honeycomb.span` calls with the following
+    ```ruby
+    Honeycomb.start_span(name: "interesting") do |span|
+      span.add_field("name", "value")
+    end
+    ```
+
+## honeycomb-rails to beeline-ruby
+
+1. Update Gemfile, remove `honeycomb-rails` and add `beeline-ruby`
+1. Run `bundle install`
+1. Remove the `honeycomb.rb` initializer from `config/initializers`
+1. Add the following to the `config.ru` file
+    ```ruby
+    # config.ru
+    require 'honeycomb-beeline'
+
+    Honeycomb.init(writekey: 'YOUR_API_KEY', dataset: 'YOUR_DATASET')
+
+    # these next two lines should already exist in some form in this file, it's important to init the honeycomb library before this
+    require ::File.expand_path('../config/environment', __FILE__)
+    run Rails.application
+    ```
+1. You can use the same write key and dataset from the honeycomb initialiser above, note: the honeycomb-beeline only supports sending events to one dataset. This is due to the fact that the new beeline will include traces for your application by default and these are only viewable from within the same dataset
+1. Replace any `honeycomb_metadata` calls in your controllers like the following
+    ```ruby
+    def index
+      @bees = Bee.all
+      Rack::Honeycomb.add_field(request.env, :bees_count, @bees.count)
+      # honeycomb_metadata[:bees_count] = @bees.count
+    end
+    ```
+1. If you are manually using the libhoney client as well, it is suggested that you remove the usages of it and rely on the beeline.
+1. Instrument interesting calls using the new `span` API as per the example below
+    ```ruby
+      class HomeController < ApplicationController
+        def index
+          Honeycomb.span do
+            @interesting_information = perform_intensive_calculations(params[:honey])
+          end
+        end
+      end
+    ```
+1. `honeycomb-rails` had the ability to automatically populate user information onto your events. Unfortunately `beeline-ruby` does not support this out of the box. You can use something like this snippet below to continue populating this (example for Devise)
+    ```ruby
+    class ApplicationController < ActionController::Base
+      before_action do
+        Rack::Honeycomb.add_field(request.env, "user.id", current_user.id)
+        Rack::Honeycomb.add_field(request.env, "user.email", current_user.email)
+      end
+    end
+    ```
+1. (Optional) If you are using `Sequel` for database access there are some additional steps to configure
+    ```ruby
+    # config.ru
+    require 'honeycomb-beeline'
+    require 'sequel-honeycomb/auto_install'
+
+    Honeycomb.init(writekey: 'YOUR_API_KEY', dataset: 'YOUR_DATASET')
+    Sequel::Honeycomb::AutoInstall.auto_install!(honeycomb_client: Honeycomb.client, logger: Honeycomb.logger)
+
+    # these next two lines should already exist in some form in this file, it's important to init the honeycomb library before this
+    require ::File.expand_path('../config/environment', __FILE__)
+    run Rails.application
+    ```

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "honeycomb/beeline"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/bundler_version.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+set -uex
+
+if [[ "$BUNDLE_GEMFILE" =~ (rails_41.gemfile|rails_42.gemfile)$ ]]; then
+  if [[ "$TRAVIS_RUBY_VERSION" =~ ^(2.3)$ ]]; then
+    gem uninstall -v '>= 2' -i $(rvm gemdir) -ax bundler
+  elif [[ "$TRAVIS_RUBY_VERSION" =~ ^(2.4|2.5)$ ]]; then
+    gem uninstall -v '>= 2' -i $(rvm gemdir)@global -ax bundler
+  fi
+  gem install bundler -v '< 2'
+fi

data/honeycomb-beeline.gemspec

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "honeycomb/beeline/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = Honeycomb::Beeline::NAME
+  spec.version       = Honeycomb::Beeline::VERSION
+  spec.authors       = ["Martin Holman"]
+  spec.email         = ["martin@honeycomb.io"]
+
+  spec.summary       = "Instrument your Ruby apps with Honeycomb"
+  spec.homepage      = "https://honeycomb.io"
+
+  spec.license = 'Apache-2.0'
+
+  spec.required_ruby_version = ">= 2.2.0"
+
+  if spec.respond_to?(:metadata)
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://github.com/honeycombio/beeline-ruby"
+  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.dirname(__FILE__)) do
+    `git ls-files -z`.split("\x0").reject do |file|
+      file.match(%r{^(test|spec|features|examples|gemfiles)/})
+    end
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "libhoney", "~> 1.8"
+
+  spec.add_development_dependency "appraisal"
+  spec.add_development_dependency "bump"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "overcommit", "~> 0.46.0"
+  spec.add_development_dependency "pry-byebug"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rubocop", "< 0.69"
+  spec.add_development_dependency "rubocop-performance", "< 1.3.0"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "simplecov-console"
+  spec.add_development_dependency "webmock"
+end

data/lib/generators/honeycomb/honeycomb_generator.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+##
+# Generates an intializer for configuring the Honeycomb beeline
+#
+class HoneycombGenerator < Rails::Generators::Base
+  source_root File.expand_path("templates", __dir__)
+
+  argument :write_key, required: true, desc: "required"
+
+  gem "honeycomb-beeline"
+
+  desc "Configures honeycomb with your write key"
+
+  def create_initializer_file
+    initializer "honeycomb.rb" do
+      <<-RUBY.strip_heredoc
+        Honeycomb.configure do |config|
+          config.write_key = #{write_key.inspect}
+          config.dataset = "rails"
+          config.notification_events = %w[
+            sql.active_record
+            render_template.action_view
+            render_partial.action_view
+            render_collection.action_view
+            process_action.action_controller
+            send_file.action_controller
+            send_data.action_controller
+            deliver.action_mailer
+          ].freeze
+        end
+      RUBY
+    end
+  end
+end

data/lib/honeycomb-beeline.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "libhoney"
+
+require "honeycomb/beeline/version"
+require "honeycomb/client"
+require "honeycomb/trace"
+
+# main module
+module Honeycomb
+  class << self
+    attr_reader :client
+
+    def configure
+      Configuration.new.tap do |config|
+        yield config
+        @client = Honeycomb::Client.new(client: config.client,
+                                        service_name: config.service_name)
+        config.after_initialize(@client)
+      end
+
+      @client
+    end
+
+    def start_span(name:, &block)
+      client.start_span(name: name, &block)
+    end
+
+    def load_integrations
+      %i[faraday rack sinatra rails sequel active_support].each do |integration|
+        begin
+          require "honeycomb/integrations/#{integration}"
+        rescue LoadError
+        end
+      end
+    end
+  end
+
+  # Used to configure the Honeycomb client
+  class Configuration
+    attr_accessor :write_key,
+                  :dataset,
+                  :api_host
+
+    attr_writer :service_name, :client
+
+    def initialize
+      @write_key = ENV["HONEYCOMB_WRITEKEY"]
+      @dataset = ENV["HONEYCOMB_DATASET"]
+      @service_name = ENV["HONEYCOMB_SERVICE"]
+      @client = nil
+    end
+
+    def service_name
+      @service_name || dataset
+    end
+
+    def client
+      options = {}.tap do |o|
+        o[:writekey] = write_key
+        o[:dataset] = dataset
+        api_host && o[:api_host] = api_host
+      end
+
+      @client || Libhoney::Client.new(options)
+    end
+
+    def after_initialize(client)
+      super(client) if defined?(super)
+    end
+  end
+end
+
+Honeycomb.load_integrations unless ENV["HONEYCOMB_DISABLE_AUTOCONFIGURE"]

data/lib/honeycomb/beeline/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Honeycomb
+  module Beeline
+    NAME = "honeycomb-beeline".freeze
+    VERSION = "1.0.0-alpha1".freeze
+    USER_AGENT_SUFFIX = "#{NAME}/#{VERSION}".freeze
+  end
+end

data/lib/honeycomb/client.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "socket"
+require "forwardable"
+require "honeycomb/beeline/version"
+require "honeycomb/context"
+
+module Honeycomb
+  # The Honeycomb Beeline client
+  class Client
+    extend Forwardable
+
+    def initialize(client:, service_name: nil)
+      # attempt to set the user_agent_addition, this will only work if the
+      # client has not sent an event prior to being passed in here. This should
+      # be most cases
+      client.instance_variable_set(:@user_agent_addition,
+                                   Honeycomb::Beeline::USER_AGENT_SUFFIX)
+      client.add_field "meta.beeline_version", Honeycomb::Beeline::VERSION
+      client.add_field "meta.local_hostname", host_name
+
+      # maybe make `service_name` a required parameter
+      client.add_field "service_name", service_name
+      @client = client
+      @context = Context.new
+
+      at_exit do
+        client.close
+      end
+    end
+
+    def start_span(name:, serialized_trace: nil)
+      if context.current_trace.nil?
+        Trace.new(serialized_trace: serialized_trace,
+                  builder: client.builder,
+                  context: context)
+      else
+        context.current_span.create_child
+      end
+
+      context.current_span.add_field("name", name)
+
+      if block_given?
+        begin
+          yield context.current_span
+        rescue StandardError => e
+          context.current_span.add_field("request.error", e.class.name)
+          context.current_span.add_field("request.error_detail", e.message)
+          raise e
+        ensure
+          context.current_span.send
+        end
+      else
+        context.current_span
+      end
+    end
+
+    def add_field(key, value)
+      return if context.current_span.nil?
+
+      context.current_span.add_field("app.#{key}", value)
+    end
+
+    def add_field_to_trace(key, value)
+      return if context.current_span.nil?
+
+      context.current_span.trace.add_field("app.#{key}", value)
+    end
+
+    private
+
+    attr_reader :client, :context
+
+    def host_name
+      # Send the heroku dyno name instead of hostname if available
+      ENV["DYNO"] || Socket.gethostname
+    end
+  end
+end

data/lib/honeycomb/context.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Honeycomb
+  # Stores the current span and trace context
+  class Context
+    def current_trace
+      return if current_span.nil?
+
+      current_span.trace
+    end
+
+    def current_span
+      spans.last
+    end
+
+    def current_span=(span)
+      spans << span
+    end
+
+    def span_sent(span)
+      spans.last != span && raise(ArgumentError, "Incorrect span sent")
+
+      spans.pop
+    end
+
+    private
+
+    def spans
+      storage["spans"] ||= []
+    end
+
+    def storage
+      Thread.current[thread_key] ||= {}
+    end
+
+    def thread_key
+      @thread_key ||= ["honeycomb", self.class.name, object_id].join("-")
+    end
+  end
+end