jaeger-client 0.7.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 447a7b165ab77c10cd4d758f2e1ba0328251d9fd143966f406dd0a726d8c2ce0
-  data.tar.gz: 6fce14b5c113ef4ad60e917d5085ecead91f00ce2a6baaf05878026f2ff04bcb
+  metadata.gz: 042e36b2c3502fb1fe7f8c0d42bd1e5130a3adc2d1bce002c466fc0374c4d6c6
+  data.tar.gz: a95a574d111ecdd1625bd760603dba7b766b748608a77ddba6c4ada33a94e4aa
 SHA512:
-  metadata.gz: fc5eac14ee4471ac96daec09e5a5bd84a9e9ef86133480339d91e7490bc13b82fa127d3421036fc22c41c0dc49542cef5a6327c8fbab88f17b7bce3a117ee880
-  data.tar.gz: b4df5beac2b6ff98ee6153e802edebc352de7b872105c9be332ddf5ad34b4818fce489aa987800f88f211505750146cd083d58709058b6d9d8204c6902a94447
+  metadata.gz: 6d63a549e13b8ca7779860c6f5dab455894690efe49ad2d6c5beb85ddf0775bbedf5c4030ba8fa6e2062cf5cf627507cc49c46e1faa0ee886edfaff480b578d0
+  data.tar.gz: af363f9831e2219053d260a9d120cebfc6bec8fa90d5b236351051a48c70203531a62a63783b9cf99417449e9762197462177c57f8f183340db5bd7755582af9

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "idl"]
+	path = idl
+	url = https://github.com/jaegertracing/jaeger-idl.git

data/.rubocop.yml

@@ -48,3 +48,6 @@ Style/FrozenStringLiteralComment:
 
 Metrics/LineLength:
   Max: 120
+
+Style/SingleLineMethods:
+  Enabled: false

data/.travis.yml

@@ -1,5 +1,14 @@
 sudo: false
+
 language: ruby
 rvm:
-  - 2.4.0
-before_install: gem install bundler -v 1.14.4
+  - 2.5.0
+
+services:
+  - docker
+
+before_install: gem install bundler -v 1.17.2
+
+script:
+  - bundle exec rake
+  - make crossdock

data/Makefile

@@ -0,0 +1 @@
+-include crossdock/rules.mk

data/README.md

@@ -28,29 +28,129 @@ OpenTracing.start_active_span('span name') do
 end
 ```
 
-The tracer can also take an externally configured sender. For example, the `HttpSender` can be configured with a different endpoint and headers for authentication.
+See [opentracing-ruby](https://github.com/opentracing/opentracing-ruby) for more examples.
+
+### Reporters
+
+#### RemoteReporter (default)
+
+RemoteReporter buffers spans in memory and sends them out of process using Sender.
+
+There are two senders: `UdpSender` (default) and `HttpSender`.
+
+To use `HttpSender`:
+
 ```ruby
-require 'jaeger/client'
-require 'jaeger/client/http_sender'
+OpenTracing.global_tracer = Jaeger::Client.build(
+  service_name: 'service_name',
+  reporter: Jaeger::Reporters::RemoteReporter.new(
+    sender: Jaeger::HttpSender.new(
+      url: 'http://localhost:14268/api/traces',
+      headers: { 'key' => 'value' }, # headers key is optional
+      encoder: Jaeger::Encoders::ThriftEncoder.new(service_name: 'service_name')
+    ),
+    flush_interval: 10
+  )
+)
+```
+
+#### NullReporter
 
-headers = { "auth_token" => token }
-encoder = Jaeger::Client::Encoders::ThriftEncoder.new(service_name: "service_name")
-sender = Jaeger::Client::HttpSender.new(url: "http://localhost:14268/api/traces", headers: headers, encoder: encoder)
+NullReporter ignores all spans.
 
-OpenTracing.global_tracer = Jaeger::Client.build(service_name: "service_name", sender: sender)
+```ruby
+OpenTracing.global_tracer = Jaeger::Client.build(
+  service_name: 'service_name',
+  reporter: Jaeger::Reporters::NullReporter.new
+)
 ```
 
-See [opentracing-ruby](https://github.com/opentracing/opentracing-ruby) for more examples.
+#### LoggingReporter
+
+LoggingReporter prints some details about the span using `logger`. This is meant only for debugging. Do not parse and use this information for anything critical. The implemenation can change at any time.
+
+```ruby
+OpenTracing.global_tracer = Jaeger::Client.build(
+  service_name: 'service_name',
+  reporter: Jaeger::Reporters::LoggingReporter.new
+)
+```
+
+LoggingReporter can also use a custom logger. For this provide logger using `logger` keyword argument.
 
 ### Samplers
 
 #### Const sampler
 
-`Const` sampler always makes the same decision for new traces depending on the initialization value. Set `sampler` to: `Jaeger::Client::Samplers::Const.new(true)` to mark all new traces as sampled.
+`Const` sampler always makes the same decision for new traces depending on the initialization value. Set `sampler` to: `Jaeger::Samplers::Const.new(true)` to mark all new traces as sampled.
 
 #### Probabilistic sampler
 
-`Probabilistic` sampler samples traces with probability equal to `rate` (must be between 0.0 and 1.0). This can be enabled by setting `Jaeger::Client::Samplers::Probabilistic.new(rate: 0.1)`
+`Probabilistic` sampler samples traces with probability equal to `rate` (must be between 0.0 and 1.0). This can be enabled by setting `Jaeger::Samplers::Probabilistic.new(rate: 0.1)`
+
+#### RateLimiting sampler
+
+`RateLimiting` sampler samples at most `max_traces_per_second`. The distribution of sampled traces follows burstiness of the service, i.e. a service with uniformly distributed requests will have those requests sampled uniformly as well, but if requests are bursty, especially sub-second, then a number of sequential requests can be sampled each second.
+
+Set `sampler` to `Jaeger::Samplers::RateLimiting.new(max_traces_per_second: 100)`
+
+#### GuaranteedThroughputProbabilistic sampler
+
+`GuaranteedThroughputProbabilistic` is a sampler that guarantees a throughput by using a Probabilistic sampler and RateLimiting sampler The RateLimiting sampler is used to establish a lower_bound so that every operation is sampled at least once in the time interval defined by the lower_bound.
+
+Set `sampler` to `Jaeger::Samplers::GuaranteedThroughputProbabilistic.new(lower_bound: 10, rate: 0.001)`
+
+#### PerOperation sampler
+
+`PerOperation` sampler leverages both Probabilistic sampler and RateLimiting sampler via the GuaranteedThroughputProbabilistic sampler. This sampler keeps track of all operations and delegates calls the the respective GuaranteedThroughputProbabilistic sampler.
+
+Set `sampler` to
+```ruby
+  Jaeger::Samplers::PerOperation.new(
+    strategies: {
+      per_operation_strategies: [
+        { operation: 'GET /articles', probabilistic_sampling: { sampling_rate: 0.5 } },
+        { operation: 'POST /articles', probabilistic_sampling: { sampling_rate: 1.0 } }
+      ],
+      default_sampling_probability: 0.001,
+      default_lower_bound_traces_per_second: 1.0 / (10.0 * 60.0)
+    },
+    max_operations: 1000
+  )
+```
+
+#### RemoteControlled sampler
+
+`RemoteControlled` sampler is a sampler that is controller by jaeger agent. It starts out with `Probabilistic` sampler. It polls the jaeger-agent and changes sampling strategy accordingly. Set `sampler` to `Jaeger::Client::Samplers::RemoteControlled.new(service_name: 'service_name')`.
+
+RemoteControlled sampler options:
+
+| Param             | Required | Description |
+|-------------------|----------|-------------|
+| service_name      | x | name of the current service / application, same as given to Tracer |
+| sampler           |   | initial sampler to use prior to retrieving strategies from Agent |
+| refresh_interval  |   | interval in seconds before sampling strategy refreshes (0 to not refresh, defaults to 60) |
+| host              |   | host for jaeger-agent (defaults to 'localhost') |
+| port              |   | port for jaeger-agent for SamplingManager endpoint (defaults to 5778) |
+| logger            |   | logger for communication between jaeger-agent (default to $stdout logger) |
+
+### TraceContext compatible header propagation
+
+It is possible to use [W3C Trace Context](https://www.w3.org/TR/trace-context/#overview) headers to propagate the tracing information.
+
+To set it up you need to change FORMAT_RACK injector and extractor.
+
+```ruby
+OpenTracing.global_tracer = Jaeger::Client.build(
+  service_name: 'service_name',
+  injectors: {
+    OpenTracing::FORMAT_RACK => [Jaeger::Injectors::TraceContextRackCodec]
+  },
+  extractors: {
+    OpenTracing::FORMAT_RACK => [Jaeger::Extractors::TraceContextRackCodec]
+  }
+)
+```
 
 ### Zipkin HTTP B3 compatible header propagation
 
@@ -58,14 +158,14 @@ Jaeger Tracer supports Zipkin B3 Propagation HTTP headers, which are used by a l
 
 To set it up you need to change FORMAT_RACK injector and extractor.
 
-```
+```ruby
 OpenTracing.global_tracer = Jaeger::Client.build(
   service_name: 'service_name',
   injectors: {
-    OpenTracing::FORMAT_RACK => [Jaeger::Client::Injectors::B3RackCodec]
+    OpenTracing::FORMAT_RACK => [Jaeger::Injectors::B3RackCodec]
   },
   extractors: {
-    OpenTracing::FORMAT_RACK => [Jaeger::Client::Extractors::B3RackCodec]
+    OpenTracing::FORMAT_RACK => [Jaeger::Extractors::B3RackCodec]
   }
 )
 ```
@@ -74,6 +174,20 @@ It's also possible to set up multiple injectors and extractors. Each injector wi
 
 If multiple extractors is used then the span context from the first match will be returned.
 
+### Process Tags
+
+Jaeger Tracer allows you to define process level tags. By default the tracer provides `jaeger.version`, `ip` and `hostname`. You may want to overwrite `ip` or `hostname` if the tracer cannot auto-detect them.
+
+```ruby
+OpenTracing.global_tracer = Jaeger::Client.build(
+  service_name: 'service_name',
+  tags: {
+    'hostname' => 'custom-hostname',
+    'custom_tag' => 'custom-tag-value'
+  }
+)
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/crossdock/Dockerfile

@@ -0,0 +1,29 @@
+FROM ruby:2.5-alpine
+
+ENV APP_HOME /app
+
+# git is required by bundler to run jaeger gem with local path
+RUN apk add --no-cache git
+
+# Add only files needed for installing gem dependencies. This allows us to
+# change other files without needing to install gems every time when building
+# the docker image.
+ADD Gemfile Gemfile.lock jaeger-client.gemspec $APP_HOME/
+ADD lib/jaeger/client/version.rb $APP_HOME/lib/jaeger/client/
+ADD crossdock/Gemfile crossdock/Gemfile.lock $APP_HOME/crossdock/
+
+RUN apk add --no-cache --virtual .app-builddeps build-base \
+  && cd $APP_HOME && bundle install \
+  && cd $APP_HOME/crossdock && bundle install \
+  && apk del .app-builddeps
+
+ADD . $APP_HOME
+
+RUN chown -R nobody:nogroup $APP_HOME
+USER nobody
+
+WORKDIR $APP_HOME/crossdock
+
+CMD ["bundle", "exec", "./server"]
+
+EXPOSE 8080-8082

data/crossdock/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'jaeger-client', path: '../'
+gem 'rack'
+gem 'sinatra'
+gem 'webrick', '~> 1.4.2'

data/crossdock/Gemfile.lock

@@ -0,0 +1,35 @@
+PATH
+  remote: ..
+  specs:
+    jaeger-client (0.7.1)
+      opentracing (~> 0.3)
+      thrift
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    mustermann (1.0.3)
+    opentracing (0.4.3)
+    rack (2.0.6)
+    rack-protection (2.0.4)
+      rack
+    sinatra (2.0.4)
+      mustermann (~> 1.0)
+      rack (~> 2.0)
+      rack-protection (= 2.0.4)
+      tilt (~> 2.0)
+    thrift (0.11.0.0)
+    tilt (2.0.9)
+    webrick (1.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  jaeger-client!
+  rack
+  sinatra
+  webrick (~> 1.4.2)
+
+BUNDLED WITH
+   1.16.2

data/crossdock/docker-compose.yml

@@ -0,0 +1,68 @@
+version: '2'
+
+services:
+  crossdock:
+    image: crossdock/crossdock
+    links:
+      - test_driver
+      - go
+      - python
+      - java
+      - ruby
+    environment:
+      - WAIT_FOR=test_driver,go,python,java,ruby
+      - WAIT_FOR_TIMEOUT=60s
+
+      - CALL_TIMEOUT=60s
+
+      - AXIS_CLIENT=go
+
+      - AXIS_S1NAME=go,python,java,ruby
+      - AXIS_SAMPLED=true,false
+      - AXIS_S2NAME=go,python,java,ruby
+      - AXIS_S2TRANSPORT=http
+      - AXIS_S3NAME=go,python,java,ruby
+      - AXIS_S3TRANSPORT=http
+
+      - BEHAVIOR_TRACE=client,s1name,sampled,s2name,s2transport,s3name,s3transport
+
+      - AXIS_TESTDRIVER=test_driver
+      - AXIS_SERVICES=ruby
+
+      - BEHAVIOR_ENDTOEND=testdriver,services
+
+      - REPORT=compact
+  go:
+    image: jaegertracing/xdock-go
+    ports:
+      - "8080-8082"
+
+  java:
+    image: jaegertracing/xdock-java
+    depends_on:
+      - jaeger-agent
+    ports:
+      - "8080-8082"
+
+  python:
+    image: jaegertracing/xdock-py
+    depends_on:
+      - jaeger-agent
+    ports:
+      - "8080-8082"
+
+  ruby:
+    build:
+      context: ../.
+      dockerfile: crossdock/Dockerfile
+    ports:
+      - "8080-8082"
+
+  test_driver:
+    image: jaegertracing/test-driver
+    depends_on:
+      - jaeger-query
+      - jaeger-collector
+      - jaeger-agent
+    ports:
+      - "8080"

data/crossdock/jaeger-docker-compose.yml

@@ -0,0 +1,48 @@
+version: '2'
+
+services:
+    jaeger-collector:
+      image: jaegertracing/jaeger-collector
+      command: ["--cassandra.keyspace=jaeger_v1_dc1", "--cassandra.servers=cassandra", "--collector.zipkin.http-port=9411"]
+      ports:
+        - "14269"
+        - "14268:14268"
+        - "14267"
+        - "14250"
+        - "9411:9411"
+      restart: on-failure
+      depends_on:
+        - cassandra-schema
+
+    jaeger-query:
+      image: jaegertracing/jaeger-query
+      command: ["--cassandra.keyspace=jaeger_v1_dc1", "--cassandra.servers=cassandra"]
+      ports:
+        - "16686:16686"
+        - "16687"
+      restart: on-failure
+      depends_on:
+        - cassandra-schema
+
+    jaeger-agent:
+      image: jaegertracing/jaeger-agent
+      # FIXME temporarily switching back to tchannel
+      # https://github.com/jaegertracing/jaeger/issues/1229
+      command: ["--reporter.tchannel.host-port=jaeger-collector:14267"]
+      ports:
+        - "5775:5775/udp"
+        - "6831:6831/udp"
+        - "6832:6832/udp"
+        - "5778:5778"
+      restart: on-failure
+      depends_on:
+        - jaeger-collector
+
+    cassandra:
+      image: cassandra:3.9
+
+    cassandra-schema:
+      image: jaegertracing/jaeger-cassandra-schema
+      depends_on:
+        - cassandra
+

data/crossdock/rules.mk

@@ -0,0 +1,35 @@
+XDOCK_YAML=crossdock/docker-compose.yml
+TRACETEST_THRIFT=idl/thrift/crossdock/tracetest.thrift
+JAEGER_COMPOSE_URL=https://raw.githubusercontent.com/jaegertracing/jaeger/master/crossdock/jaeger-docker-compose.yml
+XDOCK_JAEGER_YAML=crossdock/jaeger-docker-compose.yml
+
+.PHONY: clean-compile
+clean-compile:
+	find . -name '*.pyc' -exec rm {} \;
+
+.PHONY: docker
+docker: clean-compile crossdock-download-jaeger
+	docker build -f crossdock/Dockerfile -t jaeger-client-ruby .
+
+.PHONY: crossdock
+crossdock: ${TRACETEST_THRIFT} crossdock-download-jaeger
+	docker-compose -f $(XDOCK_YAML) -f $(XDOCK_JAEGER_YAML) kill ruby
+	docker-compose -f $(XDOCK_YAML) -f $(XDOCK_JAEGER_YAML) rm -f ruby
+	docker-compose -f $(XDOCK_YAML) -f $(XDOCK_JAEGER_YAML) build ruby
+	docker-compose -f $(XDOCK_YAML) -f $(XDOCK_JAEGER_YAML) run crossdock
+
+.PHONY: crossdock-fresh
+crossdock-fresh: ${TRACETEST_THRIFT} crossdock-download-jaeger
+	docker-compose -f $(XDOCK_YAML) -f $(XDOCK_JAEGER_YAML) kill
+	docker-compose -f $(XDOCK_YAML) -f $(XDOCK_JAEGER_YAML) rm --force
+	docker-compose -f $(XDOCK_YAML) -f $(XDOCK_JAEGER_YAML) pull
+	docker-compose -f $(XDOCK_YAML) -f $(XDOCK_JAEGER_YAML) build
+	docker-compose -f $(XDOCK_YAML) -f $(XDOCK_JAEGER_YAML) run crossdock
+
+.PHONY: crossdock-logs crossdock-download-jaeger
+crossdock-logs:
+	docker-compose -f $(XDOCK_YAML) -f $(XDOCK_JAEGER_YAML) logs
+
+.PHONY: crossdock-download-jaeger
+crossdock-download-jaeger:
+	curl -o $(XDOCK_JAEGER_YAML) $(JAEGER_COMPOSE_URL)