istox_gruf 2.7.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f392b44e82edaeae1c11c6583ec5c67312f1cc9f0f1199d80316d636edff2795
+  data.tar.gz: e2f245a831f41d47df608ce54554099ba5e594cb90d5a792512b1b350df75574
+SHA512:
+  metadata.gz: c7cd702f88a981b71c5095a49232bc3be67d8026ffbcae82a9c935c6aedb0649bd51f19cfe2fd27cfb3bdc2fa6499ae786c666a37bb90699bd5fa4e5246ed287
+  data.tar.gz: 73eabbaa8bdf9c0bfea9f4b4f046a5e3e3f0eaa7679531555499a97fd3c6425b2b48e34b6209d2f222eba8d39db63aefbf02a14955a04368d0a342dfd7d17641

data/CHANGELOG.md

@@ -0,0 +1,246 @@
+Changelog for the gruf gem. This includes internal history before the gem was made.
+
+### Pending release
+
+### 2.7.0
+
+- Add hook support for executing code paths before a server is started, and after a server stops
+
+### 2.6.1
+
+- Add frozen_string_literal: true to files, update rubocop to 0.68
+  
+### 2.6.0
+
+- Drop Ruby 2.2 support
+- Abstract gruf controller's send to make it usable in filters 
+- Adjusts configuration reset into a Railtie for Rails systems to ensure proper OOE 
+- Bump rubocop to 0.64, address violations, update activesupport/concurrent-ruby dependencies to have a min version
+
+### 2.5.2
+
+- Log ok/validation responses at DEBUG levels to prevent log stampeding in high-volume environments
+
+### 2.5.1
+
+- Ensure `timeout` is an int when passed as a client option to a gRPC client
+- Add `bound_service` reader to `Gruf::Controllers::Base` for finding the service bound to the given controller
+
+### 2.5.0
+
+- Client exceptions raised now contain mapped subclasses, such as `Gruf::Client::Errors::InvalidArgument`
+- Client exceptions will also now catch StandardError and GRPC::Core errors, and handle them as Internal errors
+- Added SynchronizedClient which prevents multiple calls to the same endpoint with the same params at
+  a given time. This is useful for mitigating thundering herds. To skip this behavior for certain endpoints,
+  pass the `options[:unsynchronized_methods]` param with a list of method names (as symbols).
+
+### 2.4.2
+
+- Added error handling for GRPC::Core::CallError, a low-level error in the grpc library that does not inherit
+  from StandardError. [#59]
+- Removed `Thread.abort\_on\_exception = true`. Exceptions should be handled by gruf or the application,
+  and should not cause the server process to crash. [#59]
+- Added guard for size of trailing metadata attached to grpc call. The default max for http2 trailing metadata
+  in the gRPC C library is 8kb. If we go over that limit (either through custom metadata attached to the
+  error by the application, or via the error payload encoded by the error serializer), the gRPC library
+  will throw RESOURCE\_EXHAUSTED. Gruf now detects this case, and attempts to prevent it by logging the
+  original error and substituting it with an internal error indicating that the metadata was too large. [#60]
+- Truncate stack trace in error payload to help avoid overflowing the trailing metadata. Added backtrace\_limit
+  configuration parameter, which defaults to 10.[#60]
+
+### 2.4.1
+
+- Safer configuration of GRPC::RpcServer. From now on, use `Gruf.rpc_server_options` for the params
+  to be sent to GPRC::RpcServer. Also provide sane defaults for params for GRPC::RpcServer. [#55]
+- Added ability to monitor `RESOURCE_EXHAUSTED` and `UNIMPLEMENTED`. By setting `event_listener_proc` in
+  the Gruf configuration, you will receive a callback when these events occur. The parameter to your
+  callback will be a symbol (`:thread_pool_exhausted` or `:unimplemented`). Others may be added in the future.
+
+### 2.4.0
+
+- Added a hash of error log levels to RequestLogging interceptor, mapping error code to level of logging to use. To
+override the level of logging per error response, provide a map of codes to log level in options, key :log_levels.
+The default is :error log level.
+
+### 2.3.0
+
+- Add Gruf::Interceptors::ClientInterceptor for intercepting outbound client calls
+- Add command-line arguments to the gruf binstub
+- Add ability to specify server hostname via CLI argument
+
+### 2.2.2
+
+- Add ignore_methods option for RequestLogging interceptor [#45]
+
+### 2.2.1
+
+- Now changes proc title once server is ready to process incoming requests [#44]
+- Gruf now requires gRPC 1.10.x+ due to various fixes and improvements in the gRPC core libraries
+
+### 2.2.0
+
+- Run server in a monitored thread to allow for trapped exits on sigints [#43]
+
+### 2.1.1
+
+- Add ability to pass in client stub options into Gruf::Client
+
+### 2.1.0
+
+- Add ability to list, clear, insert before, insert after, and remove to a server's interceptor
+registry
+- Ensure interceptors and services cannot be adjusted on the server after it starts to
+prevent threading issues
+- [#36], [#37] Adds `response_class`, `request_class`, and `service` accessors to controller request
+
+### 2.0.3
+
+- Fix regression [#35] where gruf was not able to be loaded outside of a Rails application
+
+### 2.0.2
+
+- Update Rubocop to 0.51
+- Fix issue [#32] where server was not handling signals (\ht @Parad0X)
+
+### 2.0.1
+
+- Handle ActiveRecord connection management more gracefully (Fixes #30)
+
+### 2.0.0
+
+Gruf 2.0 is a major shift from Gruf 1.0. See [UPGRADING.md](UPGRADING.md) for details.
+
+- New thread-safe controller-based model
+- New controller request object
+- Hooks deprecated in favor of interceptors
+- New interceptor timer utility class
+- Default logging to logstash formatter
+- Various Gruf::Server improvements
+
+### 1.2.7
+
+- Fix issues where field errors were persisted in between separate calls
+
+### 1.2.6
+
+- Fix issues with arity and bidirectional streaming
+
+### 1.2.5
+
+- Fix reference issue for client and bidirectional streaming calls
+
+### 1.2.4
+
+- Loosen explicit Protobuf dependency now that 3.4.0.2 is released
+- Guard against nil params in logger blacklist
+
+### 1.2.3
+
+- Support nested blacklist parameters in path.to.key format
+
+### 1.2.2
+
+- Pin Google Protobuf to 3.3.x due to failures in protobuf in Ruby at 3.4.x
+
+### 1.2.1
+
+- Added ability to pass in server options via new `server_options` configuration
+  attribute. (\ht @kruczjak)
+
+### 1.2.0
+
+- Instrumentation hooks now execute similarly to outer_around hooks; they can
+  now instrument failures
+- Instrumentation hooks now pass a `RequestContext` object that contains information
+  about the incoming request, instead of relying on instance variables
+- StatsD hook now sends success/failure metrics for endpoints
+- Add ability to turn off sending exception message on uncaught exception.
+- Add configuration to set the error message when an uncaught exception is
+  handled by gruf.
+- Add a request logging hook for Rails-style request logging, with optional
+  parameter logging, blacklists, and formatter support
+- Optimizations around Symbol casting within service calls
+
+### 1.1.0
+
+- Add the ability for call options to the client, which enables deadline setting
+
+### 1.0.0
+
+- Bump gRPC to 1.4
+
+### 0.14.2
+
+- Added rubocop style-guide checks
+
+### 0.14.1
+
+- Updated license to MIT
+
+### 0.14.0
+
+- Send gRPC status 16 (Unauthenticated) instead of 7 (PermissionDenied) when authentication fails
+
+### 0.13.0
+
+- Move to gRPC 1.3.4
+
+### 0.12.2
+
+- Add outer_around hook for wrapping the entire call chain
+
+### 0.12.1
+
+- Add ability to specify a separate gRPC logger from the Gruf logger
+
+### 0.12.0
+
+- Add ability to run multiple around hooks
+- Fix bug with error handling that caused error messages to repeat across streams
+
+### 0.11.5
+
+- Fix issue with around hook
+
+### 0.11.4
+
+- Add catchall rescue handler to capture uncaught exceptions and
+  raise a GRPC::Internal error.
+- Add Gruf.backtrace_on_error configuration value. If set, Gruf
+  will call Service.set_debug_info with the exception backtrace
+  if an uncaught exception occurs.
+
+### 0.11.3
+
+- Pass the service instance into hooks for reference
+
+### 0.11.2
+
+- Ensure timer is measuring in milliseconds
+
+### 0.11.1
+
+- Fix issue with interceptor and call signature
+
+### 0.11.0
+
+- Add instrumentation layer and ability to register new instrumentors
+- Add out-of-the-box statsd instrumentation support
+
+### 0.10.0
+
+- Rename Gruf::Endpoint to Gruf::Service
+- Make services auto-mount to server upon declaration
+
+### 0.9.2
+
+- Support mount command on services to allow automatic setup on the server
+- Cleanup and consolidate binstub to prevent need for custom binstub per-app
+
+### 0.9.1
+
+- Relax licensing to a clean BSD license
+
+### 0.9.0
+
+- Initial public release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,46 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at engineering@bigcommerce.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/README.md

@@ -0,0 +1,544 @@
+# gruf - gRPC Ruby Framework
+
+[![CircleCI](https://circleci.com/gh/bigcommerce/gruf/tree/master.svg?style=svg)](https://circleci.com/gh/bigcommerce/gruf/tree/master) [![Gem Version](https://badge.fury.io/rb/gruf.svg)](https://badge.fury.io/rb/gruf) [![Documentation](https://inch-ci.org/github/bigcommerce/gruf.svg?branch=master)](https://inch-ci.org/github/bigcommerce/gruf?branch=master)
+
+gruf is a Ruby framework that wraps the [gRPC Ruby library](https://github.com/grpc/grpc/tree/master/src/ruby) to
+provide a more streamlined integration into Ruby and Ruby on Rails applications.
+
+It provides an abstracted server and client for gRPC services, along with other tools to help get gRPC services in Ruby
+up fast and efficiently at scale. Some of its features include:
+
+* Abstracted controllers with request context support
+* Full interceptors with timing and unified request context support
+* Robust client error handling and metadata transport abilities
+* Server authentication via interceptors, with basic auth with multiple key support built in
+* TLS support for client-server auth, though we recommend using [linkerd](https://linkerd.io/) instead
+* Error data serialization in output metadata to allow fine-grained error handling in the transport while
+  still preserving gRPC BadStatus codes
+* Server and client execution timings in responses
+
+gruf currently has active support for gRPC 1.10.x+. gruf is compatible and tested with Ruby 2.2-2.5.
+gruf is also not [Rails](https://github.com/rails/rails)-specific, and can be used in any Ruby framework
+(such as [Grape](https://github.com/ruby-grape/grape), for instance).
+
+## Installation
+
+```ruby
+gem 'gruf'
+```
+
+Then in an initializer or before use:
+
+```ruby
+require 'gruf'
+```
+
+Make sure to review [UPGRADING.md](https://github.com/bigcommerce/gruf/blob/master/UPGRADING.md)
+if you are upgrading gruf between minor or major versions.
+
+### Client
+
+Add an initializer:
+
+```ruby
+require 'gruf'
+
+Gruf.configure do |c|
+  c.default_client_host = 'grpc.service.com:9003'
+end
+```
+
+If you don't explicitly set `default_client_host`, you will need to pass it into the options, like so:
+
+```ruby
+client = ::Gruf::Client.new(service: ::Demo::ThingService, options: {hostname: 'grpc.service.com:9003'})
+```
+
+From there, you can instantiate a client given a stub service (say on an SslCertificates proto with a GetSslCertificate call):
+
+```ruby
+require 'gruf'
+
+id = args[:id].to_i.presence || 1
+
+begin
+  client = ::Gruf::Client.new(service: ::Demo::ThingService)
+  response = client.call(:GetMyThing, id: id)
+  puts response.message.inspect
+rescue Gruf::Client::Error => e
+  puts e.error.inspect
+end
+```
+
+Note this returns a response object. The response object can provide `trailing_metadata` as well as a `execution_time`.
+
+### SynchronizedClient
+
+SynchronizedClient wraps Client with some additional behavior to help prevent generating spikes
+of redundant requests. If multiple calls to the same endpoint with the same parameters are made,
+the first one will be executed and the following ones will block, waiting for the first result.
+
+```ruby
+require 'gruf'
+require 'thwait'
+
+id = args[:id].to_i.presence || 1
+client = ::Gruf::SynchronizedClient.new(service: ::Demo::ThingService)
+thread1 = Thread.new { client.call(:GetMyThing, id: id) }
+thread2 = Thread.new { client.call(:GetMyThing, id: id) }
+ThreadsWait.all_waits(thread1, thread2)
+```
+
+In the above example, thread1 will make the rpc call, thread2 will block until the call is complete, and then
+will get the same value without making a second rpc call.
+
+You can also skip this behavior for certain methods if desired.
+
+```ruby
+require 'gruf'
+require 'thwait'
+
+id = args[:id].to_i.presence || 1
+client = ::Gruf::SynchronizedClient.new(service: ::Demo::ThingService, options: { unsynchronized_methods: [:GetMyThing] })
+thread1 = Thread.new { client.call(:GetMyThing, id: id) }
+thread2 = Thread.new { client.call(:GetMyThing, id: id) }
+ThreadsWait.all_waits(thread1, thread2)
+```
+
+In the above example, thread1 and thread2 will make rpc calls in parallel, in the same way as if you had used
+`Gruf::Client`.
+
+### Client Interceptors
+
+Gruf comes with an assistance class for client interceptors that you can use - or you can use the native gRPC core
+interceptors. Either way, you pass them into the `client_options` when creating a client:
+
+```ruby
+class MyInterceptor < Gruf::Interceptors::ClientInterceptor
+  def call(request_context:)
+    logger.info "Got method #{request_context.method}!"
+    yield
+  end
+end
+
+::Gruf::Client.new(
+  service: ::Demo::ThingService,
+  client_options: {
+    interceptors: [MyInterceptor.new]
+  })
+```
+
+The `interceptors` option in `client_options` can accept either a `GRPC::ClientInterceptor` class or a
+`Gruf::Interceptors::ClientInterceptor`, since the latter just extends the former. The gruf client interceptors
+take an optional alternative approach: rather than having separate methods for each request type, it provides a default
+`call` method that passes in a `RequestContext` object, which has the following attributes:
+
+* *type* - A Symbol of the type of request (`request_response`, `server_streamer`, etc)
+* *requests* An enumerable of requests being sent. For unary requests, this is a single request in an array
+* *call* - The `GRPC::ActiveCall` object
+* *method* - The Method being called
+* *metadata* - The hash of outgoing metadata
+
+Note that you _must_ yield back the block when building a client interceptor, so that the call can be executed.
+
+### Server
+
+Add an initializer:
+
+```ruby
+require 'gruf'
+
+Gruf.configure do |c|
+  c.server_binding_url = 'grpc.service.com:9003'
+end
+```
+
+Next, setup some handlers based on your proto configurations in `/app/rpc/`. For example, for the Thing service, with a
+GetThingReq/GetThingResp call based on this proto:
+
+```proto
+syntax = "proto3";
+
+package demo;
+
+service Jobs {
+    rpc GetJob(GetJobReq) returns (GetJobResp) { }
+}
+
+message GetJobReq {
+    uint64 id = 1;
+}
+
+message GetJobResp {
+    uint64 id = 1;
+    string name = 2;
+}
+```
+
+You'd have this handler in `/app/rpc/demo/job_controller.rb`
+
+```ruby
+module Demo
+  class JobController < ::Gruf::Controllers::Base
+    bind ::Demo::Jobs::Service
+
+    ##
+    # @return [Demo::GetJobResp] The job response
+    #
+    def get_job
+      thing = Job.find(request.message.id)
+
+      Demo::GetJobResp.new(id: thing.id)
+    rescue
+      fail!(:not_found, :job_not_found, "Failed to find Job with ID: #{request.message.id}")
+    end
+  end
+end
+```
+
+Finally, you can start the server by running:
+
+```bash
+bundle exec gruf
+```
+
+### Command-Line Options
+
+Gruf comes baked in with a few command-line options for the binstub:
+
+| Option | Description |
+| ------ | ----------- |
+| -h, --help | Displays the help message |
+| -v, --version | Displays the gruf version |
+| --host | Specify the server binding host |
+| --suppress-default-interceptors | Do not use the default interceptors for the server |
+| --backtrace-on-error | Push backtraces on exceptions to the error serializer |
+
+These options will override whatever is passed in the Gruf configure block or
+initializer.
+
+### Basic Authentication
+
+Gruf comes packaged in with a Basic Authentication interceptor. It takes in an array of supported
+username and password pairs (or password-only credentials).
+
+In Server:
+
+```ruby
+Gruf.configure do |c|
+  c.interceptors.use(
+    Gruf::Interceptors::Authentication::Basic,
+    credentials: [{
+      username: 'my-username-here',
+      password: 'my-password-here',
+    },{
+      username: 'another-username',
+      password: 'another-password',
+    },{
+      password: 'a-password-only'
+    }]
+  )
+end
+```
+
+In Client:
+
+```ruby
+require 'gruf'
+
+id = args[:id].to_i.presence || 1
+
+options = {
+  username: ENV.fetch('DEMO_THING_SERVICE_USERNAME'),
+  password: ENV.fetch('DEMO_THING_SERVICE_PASSWORD')
+}
+
+begin
+  client = ::Gruf::Client.new(service: ::Demo::ThingService, options: options)
+  response = client.call(:GetMyThing, id: id)
+  puts response.message.inspect
+rescue Gruf::Client::Error => e
+  puts e.error.inspect
+end
+```
+
+Supporting an array of credentials allow for unique credentials per service, or for easy credential
+rotation with zero downtime.
+
+### SSL Configuration
+
+We don't recommend using TLS for gRPC, but instead using something like [linkerd](https://linkerd.io) for TLS
+encryption between services. If you need it, however, this library supports TLS.
+
+For the client, you'll need to point to the public certificate:
+
+```ruby
+::Gruf::Client.new(
+  service: Demo::ThingService,
+  options: {
+    ssl_certificate: 'x509 public certificate here',
+    # OR
+    ssl_certificate_file: '/path/to/my.crt'
+  }
+)
+```
+
+If you want to run a server you'll need both the CRT and the key file if you want to do credentialed auth:
+
+```ruby
+Gruf.configure do |c|
+  c.use_ssl = true
+  c.ssl_crt_file = "#{Rails.root}/config/ssl/#{Rails.env}.crt"
+  c.ssl_key_file = "#{Rails.root}/config/ssl/#{Rails.env}.key"
+end
+```
+
+### GRPC::RpcServer configuration
+To customize parameters for the underlying GRPC::RpcServer, such as the size of the gRPC thread pool,
+you can pass them in via Gruf.rpc\_server\_options.
+
+```ruby
+Gruf.configure do |c|
+  # The size of the underlying thread pool. No more concurrent requests can be made
+  # than the size of the thread pool.
+  c.rpc_server_options[:pool_size] = 100
+end
+```
+
+## Server Interceptors
+
+gruf supports interceptors around the grpc server calls, allowing you to perform actions around your service
+method calls. This can be used to add tracing data, connection resets in the grpc thread pool, further
+instrumentation, and other things.
+
+Adding a hook is as simple as creating a class that extends `Gruf::Interceptor::ServerInterceptor`,
+and a `call` method that yields control to get the method result:
+
+```ruby
+class MyInterceptor < ::Gruf::Interceptors::ServerInterceptor
+  def call
+    yield
+  end
+end
+```
+
+Interceptors have access to the `request` object, which is the `Gruf::Controller::Request` object
+described above.
+
+### Failing in an Interceptor
+
+Interceptors can fail requests with the same method calls as a controller:
+
+```ruby
+class MyFailingInterceptor < ::Gruf::Interceptors::ServerInterceptor
+  def call
+    result = yield # this returns the protobuf message
+    unless result.dont_hijack
+      # we'll assume this "dont_hijack" attribute exists on the message for this example
+      fail!(:internal, :hijacked, 'Hijack all the things!')
+    end
+    result
+  end
+end
+```
+
+Similarly, you can raise `GRPC::BadStatus` calls to trigger similar errors without accompanying metadata.
+
+### Configuring Interceptors
+
+From there, the interceptor can be added to the server manually (if not executing via `bundle exec gruf`):
+
+```ruby
+server = Gruf::Server.new
+server.add_interceptor(MyInterceptor, option_foo: 'value 123')
+```
+
+Or, alternatively, the more common method of passing them into the `interceptors` configuration hash:
+
+```ruby
+Gruf.configure do |c|
+  c.interceptors.use(MyInterceptor, option_foo: 'value 123')
+end
+```
+
+Interceptors each wrap the call and are run recursively within each other. This means that if you have
+three interceptors - `Interceptor1`, `Interceptor2`, and `Interceptor3` - they will run in FIFO
+(first in, first out) order. `Interceptor1` will run, yielding to `Interceptor2`,
+which will then yield to `Interceptor3`, which will then yield to your service method call,
+ending the chain.
+
+You can utilize the `insert_before` and `insert_after` methods to maintain order:
+
+```ruby
+Gruf.configure do |c|
+  c.interceptors.use(Interceptor1)
+  c.interceptors.use(Interceptor2)
+  c.interceptors.insert_before(Interceptor2, Interceptor3) # 3 will now happen before 2
+  c.interceptors.insert_after(Interceptor1, Interceptor4) # 4 will now happen after 1
+end
+```
+
+By default, the ActiveRecord Connection Reset interceptor and Output Metadata Timing interceptor
+are loaded into gruf unless explicitly told not to via the `use_default_interceptors` configuration
+parameter.
+
+## Hooks
+
+Hooks, unlike interceptors, are executed outside of the request chain, such as when a server starts
+or stops. They run in FIFO order sequentially and do not wrap one another. They can be used to provide
+custom boot sequences, external instrumentation support, or shutdown alerting. 
+
+You can create a hook by extending the `Gruf::Hooks::Base` class and defining the methods
+on the hook you wish to implement:
+
+```ruby
+class MyHook < Gruf::Hooks::Base
+  def before_server_start(server:)
+    # do my thing before the server starts  
+  end
+  
+  def after_server_stop(server:)
+    # do my thing after the server stops
+  end
+end
+
+# Then in an initializer:
+
+Gruf.configure do |c|
+  c.hooks.use(MyHook, option_foo: 'value 123')
+end
+```
+
+Exceptions raised in hooks will halt the execution chain and bubble up the stack appropriately.
+
+### Available Hook Insertion Points
+
+Current hook insertion points are:
+
+* `before_server_start` - Right before the gRPC server starts
+* `after_server_stop` - Right after the gRPC server is shutdown
+
+Note that exceptions raised in `before_server_start` will halt the execution chain for the remaining 
+`before_server_start` hooks, but will still execute the `after_server_stop` hooks as expected. Exceptions raised
+in `after_server_stop` will prevent further `after_server_stop` hooks from running.
+
+## Instrumentation
+
+gruf comes out of the box with a couple of instrumentation interceptors packed in:
+output metadata timings and StatsD support.
+
+### Output Metadata Timing
+
+Enabled by default, this will push timings for _successful responses_ through the response output
+metadata back to the client.
+
+### StatsD
+
+The StatsD support is not enabled by default. To enable it, you'll want to do:
+
+```ruby
+Gruf.configure do |c|
+  c.interceptors.use(
+    Gruf::Interceptors::Instrumentation::Statsd,
+    client: ::Statsd.new('my.statsd.host', 8125),
+    prefix: 'my_application_prefix.rpc'
+  )
+end
+```
+
+This will measure counts and timings for each endpoint.
+
+### Request Logging
+
+Gruf 1.2+ comes built with request logging out of the box; you'll get Rails-style logs with your
+gRPC calls:
+
+```
+# plain
+I, [2017-07-14T09:50:54.200506 #70571]  INFO -- : [GRPC::Ok] (thing_service.get_thing) [0.348ms]
+# logstash
+I, [2017-07-14T09:51:03.299050 #70595]  INFO -- : {"message":"[GRPC::Ok] (thing_service.get_thing) [0.372ms]","service":"thing_service","method":"thing_service.get_thing","grpc_status":"GRPC::Ok"}
+ ```
+
+It supports formatters (including custom ones) that you can use to specify the formatting of the logging:
+
+```ruby
+Gruf.configure do |c|
+  c.interceptors.use(
+    Gruf::Interceptors::Instrumentation::RequestLogging::Interceptor,
+    formatter: :logstash
+  )
+end
+```
+
+It comes with a few more options as well:
+
+| Option | Description | Default |
+| ------ | ----------- | ------- |
+| formatter | The formatter to use. By default `:plain` and `:logstash` are supported. | `:logstash` |
+| log_parameters | If set to true, will log parameters in the response | `false` |
+| blacklist | An array of parameter key names to redact from logging, in path.to.key format | `[]` |
+| redacted_string | The string to use for redacted parameters. | `REDACTED` |
+| ignore_methods | An array of method names to ignore from logging. E.g. `['namespace.health.check']` | `[]` |
+
+It's important to maintain a safe blacklist should you decide to log parameters; gruf does no
+parameter sanitization on its own. We also recommend blacklisting parameters that may contain
+very large values (such as binary or json data).
+
+## Testing with RSpec
+
+There is a gem specifically for easy testing with RSpec: [gruf-rspec](https://github.com/bigcommerce/gruf-rspec). Take
+a look at its README for more information.
+
+## Plugins
+
+You can build your own hooks and middleware for gruf; here's a list of known open source gems for
+gruf that you can use today:
+
+* [gruf-lightstep](https://github.com/bigcommerce/gruf-lightstep) - Provides a seamless
+[LightStep](https://lightstep.com) integration
+* [gruf-zipkin](https://github.com/bigcommerce/gruf-zipkin) - Provides a [Zipkin](https://zipkin.io)
+integration
+* [gruf-newrelic](https://github.com/bigcommerce/gruf-newrelic) - Easy [New Relic](https://newrelic.com/) integration
+* [gruf-commander](https://github.com/bigcommerce/gruf-commander) - Request/command-style validation and
+execution patterns for services
+* [gruf-profiler](https://github.com/bigcommerce/gruf-profiler) - Profiles and provides memory usage
+reports for clients and services
+* [gruf-circuit-breaker](https://github.com/bigcommerce/gruf-circuit-breaker) - Circuit breaker
+support for services
+
+## Demo Rails App
+
+There is a [demonstration Rails application here](https://github.com/bigcommerce/gruf-demo) you can
+view and clone that shows how to integrate Gruf into an existing Rails application.
+
+## Roadmap
+
+### Gruf 3.0
+
+* Change configuration to an injectable object to ensure thread safety on chained server/client interactions
+* Move all references to `Gruf.` configuration into injectable parameters
+* Redo server configuration to be fully injectable
+
+## Companies Using Gruf
+
+Using gruf and want to show your support? Let us know and we'll add your name here.
+
+* [BigCommerce](https://www.bigcommerce.com/)
+
+## License
+
+Copyright (c) 2017-present, BigCommerce Pty. Ltd. All rights reserved
+
+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.