lhc 9.4.0 → 9.4.1

data/docs/interceptors/authentication.md

@@ -1,54 +0,0 @@
-# Authentication Interceptor
-
-Add the auth interceptor to your basic set of LHC interceptors.
-
-```ruby
-  LHC.config.interceptors = [LHC::Auth]
-```
-
-## Bearer Authentication
-
-```ruby
-  LHC.get('http://local.ch', auth: { bearer: -> { access_token } })
-```
-
-Adds the following header to the request:
-```
-  'Authorization': 'Bearer 123456'
-```
-
-Assuming the method `access_token` responds on runtime of the request with `123456`.
-
-## Basic Authentication
-
-```ruby
-  LHC.get('http://local.ch', auth: { basic: { username: 'steve', password: 'can' } })
-```
-
-Adds the following header to the request:
-```
-  'Authorization': 'Basic c3RldmU6Y2Fu'
-```
-
-Which is the base64 encoded credentials "username:password".
-
-# Reauthenticate
-
-The current implementation can only offer reauthenticate for _client access tokens_. For this to work the following has to be given:
-
-* You have configured and implemented `LHC::Auth.refresh_client_token = -> { TokenRefreshUtil.client_access_token(true) }` which when called will force a refresh of the token and return the new value. It is also expected that this implementation will handle invalidating caches if necessary.
-* Your interceptors contain `LHC::Auth` and `LHC::Retry`, whereas `LHC::Retry` comes _after_ `LHC::Auth` in the chain.
-
-## Bearer Authentication with client access token
-
-Reauthentication will be initiated if:
-
-* setup is correct
-* `response.success?` is false and an `LHC::Unauthorized` was observed
-* reauthentication wasn't already attempted once
-
-If this is the case, this happens:
-
-* refresh the client token, by calling `refresh_client_token`
-* the authentication header will be updated with the new token
-* `LHC::Retry` will be triggered by adding `retry: { max: 1 }` to the request options

data/docs/interceptors/caching.md

@@ -1,68 +0,0 @@
-# Caching Interceptor
-
-Add the cache interceptor to your basic set of LHC interceptors.
-
-```ruby
-  LHC.config.interceptors = [LHC::Caching]
-```
-
-You can configure your own cache (default Rails.cache) and logger (default Rails.logger):
-
-```ruby
-  LHC::Caching.cache = ActiveSupport::Cache::MemoryStore.new
-  LHC::Caching.logger = Logger.new(STDOUT)
-```
-
-Caching is not enabled by default, although you added it to your basic set of interceptors.
-If you want to have requests served/stored and stored in/from cache, you have to enable it by request.
-
-```ruby
-  LHC.get('http://local.ch', cache: true)
-```
-
-You can also enable caching when configuring an endpoint in LHS.
-
-```ruby
-  class Feedbacks < LHS::Service
-    endpoint '{+datastore}/v2/feedbacks', cache: true
-  end
-```
-
-Only GET requests are cached by default. If you want to cache any other request method, just configure it:
-
-```ruby
-  LHC.get('http://local.ch', cache: { methods: [:get] })
-```
-
-Responses served from cache are marked as served from cache:
-
-```ruby
-  response = LHC.get('http://local.ch', cache: true)
-  response.from_cache? # true
-```
-
-## Options
-
-```ruby
-  LHC.get('http://local.ch', cache: { key: 'key' expires_in: 1.day, race_condition_ttl: 15.seconds, use: ActiveSupport::Cache::MemoryStore.new })
-```
-
-`expires_in` - lets the cache expires every X seconds.
-
-`key` - Set the key that is used for caching by using the option. Every key is prefixed with `LHC_CACHE(v1): `.
-
-`race_condition_ttl` - very useful in situations where a cache entry is used very frequently and is under heavy load.
-If a cache expires and due to heavy load several different processes will try to read data natively and then they all will try to write to cache.
-To avoid that case the first process to find an expired cache entry will bump the cache expiration time by the value set in `cache_race_condition_ttl`.
-
-`use` - Set an explicit cache to be used for this request. If this option is missing `LHC::Caching.cache` is used.
-
-## Testing
-
-Add to your spec_helper.rb:
-
-```ruby
-  require 'lhc/test/cache_helper.rb'
-```
-
-This will initialize a MemoryStore cache for LHC::Caching interceptor and resets the cache before every test.

data/docs/interceptors/default_timeout.md

@@ -1,17 +0,0 @@
-# Default Timeout Interceptor
-
-Applies default timeout values to all requests made in an application, that uses LHC.
-
-```ruby
-  LHC.config.interceptors = [LHC::DefaultTimeout]
-```
-
-`timeout` default: 15 seconds
-`connecttimeout` default: 2 seconds
-
-## Overwrite defaults
-
-```ruby
-LHC::DefaultTimeout.timeout = 5 # seconds
-LHC::DefaultTimeout.connecttimeout = 3 # seconds
-```

data/docs/interceptors/logging.md

@@ -1,29 +0,0 @@
-# Logging Interceptor
-
-The logging interceptor logs all requests done with LHC to the Rails logs.
-
-## Installation
-
-```ruby
-  LHC.config.interceptors = [LHC::Logging]
-
-  LHC::Logging.logger = Rails.logger  
-```
-
-## What and how it logs
-
-The logging Interceptor logs basic information about the request and the response:
-
-```ruby
-LHC.get('http://local.ch')
-# Before LHC request<70128730317500> GET http://local.ch at 2018-05-23T07:53:19+02:00 Params={} Headers={\"User-Agent\"=>\"Typhoeus - https://github.com/typhoeus/typhoeus\", \"Expect\"=>\"\"}
-# After LHC response for request<70128730317500>: GET http://local.ch at 2018-05-23T07:53:28+02:00 Time=0ms URL=http://local.ch:80/
-```
-
-## Configure
-
-You can configure the logger beeing used by the logging interceptor:
-
-```ruby
-LHC::Logging.logger = Another::Logger
-```

data/docs/interceptors/monitoring.md

@@ -1,68 +0,0 @@
-# Monitoring Interceptor
-
-The monitoring interceptor reports all requests done with LHC to a given StatsD instance.
-
-## Installation
-
-```ruby
-  LHC.config.interceptors = [LHC::Monitoring]
-```
-
-You also have to configure statsd in order to have the monitoring interceptor report.
-
-```ruby
-  LHC::Monitoring.statsd = <your-instance-of-statsd>
-```
-
-### Environment
-
-By default, the monitoring interceptor uses Rails.env to determine the environment. In case you want to configure that, use:
-
-```ruby
-LHC::Monitoring.env = ENV['DEPLOYMENT_TYPE'] || Rails.env
-```
-
-## What it tracks
-
-It tracks request attempts with `before_request` and `after_request` (counts).
-
-In case your workers/processes are getting killed due limited time constraints, 
-you are able to detect deltas with relying on "before_request", and "after_request" counts:
-
-```ruby
-  "lhc.<app_name>.<env>.<host>.<http_method>.before_request", 1
-  "lhc.<app_name>.<env>.<host>.<http_method>.after_request", 1
-```
-
-In case of a successful response it reports the response code with a count and the response time with a gauge value.
-
-```ruby
-  LHC.get('http://local.ch')
-
-  "lhc.<app_name>.<env>.<host>.<http_method>.count", 1
-  "lhc.<app_name>.<env>.<host>.<http_method>.200", 1
-  "lhc.<app_name>.<env>.<host>.<http_method>.time", 43
-```
-
-Timeouts are also reported:
-
-```ruby
-  "lhc.<app_name>.<env>.<host>.<http_method>.timeout", 1
-```
-
-All the dots in the host are getting replaced with underscore (_), because dot is the default separator in graphite.
-
-
-## Configure
-
-It is possible to set the key for Monitoring Interceptor on per request basis:
-
-```ruby
-  LHC.get('http://local.ch', monitoring_key: 'local_website')
-
-  "local_website.count", 1
-  "local_website.200", 1
-  "local_website.time", 43
-```
-
-If you use this approach you need to add all namespaces (app, environment etc.) to the key on your own.

data/docs/interceptors/prometheus.md

@@ -1,18 +0,0 @@
-# Prometheus Interceptor
-
-Logs basic request/response information to prometheus.
-
-```ruby
-  require 'prometheus/client'
-  LHC::Prometheus.client = Prometheus::Client
-  LHC::Prometheus.namespace = 'web_location_app'
-  LHC.config.interceptors = [LHC::Prometheus]
-```
-
-```ruby
-  LHC.get('http://local.ch')
-```
-
-- Creates a prometheus counter that receives additional meta information for: `:code`, `:success` and `:timeout`.
-
-- Creates a prometheus histogram for response times in milliseconds.

data/docs/interceptors/retry.md

@@ -1,24 +0,0 @@
-# Retry Interceptor
-
-If you enable the retry interceptor, you can have LHC retry requests for you:
-
-```ruby
-  LHC.config.interceptors = [LHC::Retry]
-  response = LHC.get('http://local.ch', retry: true)
-```
-
-It will try to retry the request up to 3 times (default) internally, before it passes the last response back, or raises an error for the last response.
-
-Consider, that all other interceptors will run for every single retry.
-
-## Limit the amount of retries while making the request
-
-```ruby
-  LHC.get('http://local.ch', retry: { max: 1 })
-```
-
-## Change the default maximum of retries of the retry interceptor
-
-```ruby
-  LHC::Retry.max = 3
-```

data/docs/interceptors/rollbar.md

@@ -1,19 +0,0 @@
-# Rollbar Interceptor
-
-Forward errors to rollbar when exceptions occur during http requests.
-
-```ruby
-  LHC.config.interceptors = [LHC::Rollbar]
-```
-
-```ruby
-  LHC.get('http://local.ch')
-```
-
-If it raises, it forwards the request and response object to rollbar, which contain all necessary data.
-
-## Forward additional parameters
-
-```ruby
-  LHC.get('http://local.ch', rollbar: { tracking_key: 'this particular request' })
-```

data/docs/interceptors/zipkin.md

@@ -1,23 +0,0 @@
-# Zipkin
-
-Zipkin is a distributed tracing system. It helps gather timing data needed to troubleshoot latency problems in microservice architectures [Zipkin Distributed Tracing](https://zipkin.io/).
-
-Add the zipkin interceptor to your basic set of LHC interceptors.
-
-```ruby
-  LHC.config.interceptors = [LHC::Zipkin]
-```
-
-The following configuration needs to happen in the application that wants to run this interceptor:
-
-1. Add `gem 'zipkin-tracer'` to your Gemfile.
-2. Add the necessary Rack middleware and configuration
-
-```ruby
-config.middleware.use ZipkinTracer::RackHandler, {
-  service_name: 'service-name', # name your service will be known as in zipkin
-  service_port: 80, # the port information that is sent along the trace
-  json_api_host: 'http://zipkin-collector', # the zipkin endpoint
-  sample_rate: 1 # sample rate, where 1 = 100% of all requests, and 0.1 is 10% of all requests
-}
-```

data/docs/request.md

@@ -1,24 +0,0 @@
-Request
-===
-
-The request class handles the http request,
-implements the interceptor pattern,
-loads configured endpoints,
-generates urls from url-templates
-and raises exceptions for any response code that is not indicating success (2**).
-
-→ [Read more about exceptions](exceptions.md)
-
-```ruby
-  request.response #<LHC::Response> the associated response.
-
-  request.options #<Hash> the options used for creating the request.
-
-  request.params # access request params
-
-  request.headers # access request headers
-
-  request.url #<String> URL that is used for doing the request
-
-  request.method #<Symbol> provides the used http-method
-```

data/docs/response.md

@@ -1,19 +0,0 @@
-Response
-===
-
-```ruby
-  response.request #<LHC::Request> the associated request.
-
-  response.data #<OpenStruct> in case response body contains parsable JSON.
-  response.data.something.nested
-
-  response.body #<String>
-
-  response.code #<Fixnum>
-
-  response.headers #<Hash>
-
-  response.time #<Fixnum> Provides response time in ms.
-
-  response.timeout? #true|false
-```