ddtrace 0.50.0 → 0.53.0

data/benchmarks/postgres_database.yml

@@ -1,9 +0,0 @@
-production:
-  adapter: 'postgresql'
-  timeout: 5000
-  database: <%= ENV.fetch('TEST_POSTGRES_DB', 'postgres') %>
-  host: <%= ENV.fetch('TEST_POSTGRES_HOST', '127.0.0.1') %>
-  port: <%= ENV.fetch('TEST_POSTGRES_PORT', 5432) %>
-  username: <%= ENV.fetch('TEST_POSTGRES_USER', 'postgres') %>
-  password: <%= ENV.fetch('TEST_POSTGRES_PASSWORD', 'postgres') %>
-  pool: 30

data/benchmarks/profiler_sample_loop.rb

@@ -1,69 +0,0 @@
-require 'benchmark/ips'
-require 'ddtrace'
-require 'pry'
-
-# This benchmark measures the performance of the main stack sampling loop of the profiler
-
-class ProfilerSampleLoopBenchmark
-  def create_profiler
-    Datadog.configure do |c|
-      # c.diagnostics.debug = true
-      c.profiling.enabled = true
-      c.tracer.transport_options = proc { |t| t.adapter :test }
-    end
-
-    # Stop background threads
-    Datadog.profiler.shutdown!
-
-    # Call collection directly
-    @stack_collector = Datadog.profiler.collectors.first
-    @recorder = @stack_collector.recorder
-  end
-
-  def thread_with_very_deep_stack(depth: 500)
-    deep_stack = proc do |n|
-      if n > 0
-        deep_stack.call(n - 1)
-      else
-        sleep
-      end
-    end
-
-    Thread.new { deep_stack.call(depth) }.tap { |t| t.name = "Deep stack #{depth}" }
-  end
-
-  def run_benchmark
-    Benchmark.ips do |x|
-      x.config(time: 10, warmup: 2)
-
-      x.report("stack collector #{ENV['CONFIG']}") do
-        @stack_collector.collect_and_wait
-      end
-
-      x.save! 'profiler-sample-loop-results'
-      x.compare!
-    end
-
-    @recorder.flush
-  end
-
-  def run_forever
-    while true
-      1000.times { @stack_collector.collect_and_wait }
-      @recorder.flush
-      print '.'
-    end
-  end
-end
-
-puts "Current pid is #{Process.pid}"
-
-ProfilerSampleLoopBenchmark.new.instance_exec do
-  create_profiler
-  4.times { thread_with_very_deep_stack }
-  if ARGV.include?('--forever')
-    run_forever
-  else
-    run_benchmark
-  end
-end

data/benchmarks/profiler_submission.rb

@@ -1,93 +0,0 @@
-require 'benchmark/ips'
-require 'ddtrace'
-require 'pry'
-
-# This benchmark measures the performance of encoding pprofs and trying to submit them
-#
-# The FLUSH_DUMP_FILE (by default benchmarks/data/profiler-submission-marshal.gz, gathered from benchmarking using
-# the discourse forum rails app) can be generated by changing the scheduler.rb#flush_events to dump the contents of
-# "flush" to a file during a benchmark execution:
-#
-# dump_file = "marshal-#{Time.now.utc.to_i}.dump"
-# File.open(dump_file, "w") { |f| Marshal.dump(flush, f) }
-# Datadog.logger.info("Dumped to #{dump_file}")
-#
-# And then gzipping the result. (This can probably be automated a bit by adding an extra exporter, but the above worked
-# for me).
-
-class ProfilerSubmission
-  def create_profiler
-    @adapter_buffer = []
-
-    Datadog.configure do |c|
-      # c.diagnostics.debug = true
-      c.profiling.enabled = true
-      c.tracer.transport_options = proc { |t| t.adapter :test, @adapter_buffer }
-    end
-
-    # Stop background threads
-    Datadog.profiler.shutdown!
-
-    # Call exporter directly
-    @exporter = Datadog.profiler.scheduler.exporters.first
-    @flush = Marshal.load(
-      Zlib::GzipReader.new(File.open(ENV['FLUSH_DUMP_FILE'] || 'benchmarks/data/profiler-submission-marshal.gz'))
-    )
-  end
-
-  def check_valid_pprof
-    output_pprof = @adapter_buffer.last[:form]["data[0]"].io
-
-    expected_hashes = [
-      "75c65dec2d5d750faca3e905486c39ba44219636ac1bea15d5d624b741d4b62a",
-      "6780c47b3e271f2abe0346fd40ac358f6a34270b3a8f5743aacd1970bbbbc6f5"
-    ]
-    current_hash = Digest::SHA256.hexdigest(Zlib::GzipReader.new(output_pprof).read)
-
-    if expected_hashes.include?(current_hash)
-      puts "Output hash #{current_hash} matches known signature"
-    else
-      puts "WARNING: Unexpected pprof output -- unknown hash. Hashes seem to differ due to some of our dependencies changing, " \
-        "but it can also indicate that encoding output has become corrupted."
-    end
-  end
-
-  def run_benchmark
-    Benchmark.ips do |x|
-      x.config(time: 10, warmup: 2)
-
-      x.report("exporter #{ENV['CONFIG']}") do
-        run_once
-      end
-
-      x.save! 'profiler-submission-results.json'
-      x.compare!
-    end
-  end
-
-  def run_forever
-    while true
-      run_once
-      print '.'
-    end
-  end
-
-  def run_once
-    @adapter_buffer.clear
-    @exporter.export(@flush)
-  end
-end
-
-puts "Current pid is #{Process.pid}"
-
-ProfilerSubmission.new.instance_exec do
-  create_profiler
-  run_once
-  check_valid_pprof
-
-  if ARGV.include?('--forever')
-    run_forever
-  else
-    run_benchmark
-  end
-end

data/benchmarks/sidekiq_test.rb

@@ -1,154 +0,0 @@
-ENV['RAILS_ENV'] = 'production'
-require 'English'
-
-# Benchmark Configuration container
-module TestConfiguration
-  module_function
-
-  def sidekiq
-    Sidekiq.options.tap do |options|
-      options[:tag] = 'test'
-      options[:queues] << 'default'
-      options[:concurrency] = 20
-      options[:timeout] = 2
-    end
-  end
-
-  def redis
-    { pool_size: 30, timeout: 3 }
-  end
-
-  def iteration_count
-    1000
-  end
-end
-
-require 'bundler/setup'
-require 'rails/all'
-Bundler.require(*Rails.groups)
-
-# Example Rails App
-module SampleApp
-  class Application < Rails::Application; end
-end
-
-# Overrides rails configueration locations
-module OverrideConfiguration
-  def paths
-    super.tap { |path| path.add 'config/database', with: 'benchmarks/postgres_database.yml' }
-  end
-end
-
-Rails::Application::Configuration.prepend(OverrideConfiguration)
-
-Rails.application.configure do
-  config.cache_classes = true
-  config.eager_load = true
-  config.active_job.queue_adapter = :sidekiq
-end
-
-ActiveRecord::Base.configurations = Rails.application.config.database_configuration
-Rails.application.initialize!
-
-ActiveRecord::Schema.define do
-  drop_table(:samples) if connection.table_exists?(:samples)
-
-  create_table :samples do |t|
-    t.string :name
-    t.timestamps
-  end
-end
-
-class Sample < ActiveRecord::Base; end
-
-require 'sidekiq/launcher'
-require 'sidekiq/cli'
-require 'concurrent/atomic/atomic_fixnum'
-
-Sidekiq.configure_server do |config|
-  redis_conn = proc do
-    Redis.new(
-      host: ENV.fetch('TEST_REDIS_HOST', '127.0.0.1'),
-      port: ENV.fetch('TEST_REDIS_PORT', 6379)
-    )
-  end
-  config.redis = ConnectionPool.new(size: TestConfiguration.redis[:pool_size],
-                                    timeout: TestConfiguration.redis[:timeout],
-                                    &redis_conn)
-end
-
-# Simple Sidekiq worker performing the real benchmark
-class Worker
-  class << self
-    attr_reader :iterations, :conditional_variable
-  end
-
-  @iterations = Concurrent::AtomicFixnum.new(0)
-  @conditional_variable = ConditionVariable.new
-
-  include Sidekiq::Worker
-  def perform(iter, max_iterations)
-    self.class.iterations.increment
-    self.class.conditional_variable.broadcast if self.class.iterations.value > max_iterations
-
-    Sample.create!(name: iter.to_s).save
-
-    100.times do
-      Sample.last.name
-    end
-
-    Sample.last(100).to_a
-  end
-end
-
-if Datadog.respond_to?(:configure)
-  Datadog.configure do |d|
-    d.use :rails, enabled: true, tags: { 'tag' => 'value' }
-    d.use :http
-    d.use :sidekiq, service_name: 'service'
-    d.use :redis
-    d.use :dalli
-    d.use :resque, workers: [Worker]
-
-    processor = Datadog::Pipeline::SpanProcessor.new do |span|
-      true if span.service == 'B'
-    end
-
-    Datadog::Pipeline.before_flush(processor)
-  end
-end
-
-def current_memory
-  `ps -o rss #{$PROCESS_ID}`.split("\n")[1].to_f / 1024
-end
-
-def time
-  Process.clock_gettime(Process::CLOCK_MONOTONIC)
-end
-
-def launch(iterations, options)
-  iterations.times do |i|
-    Worker.perform_async(i, iterations)
-  end
-
-  launcher = Sidekiq::Launcher.new(options)
-  launcher.run
-end
-
-def wait_and_measure(iterations)
-  start = time
-
-  STDERR.puts "#{time - start}, #{current_memory}"
-
-  mutex = Mutex.new
-
-  while Worker.iterations.value < iterations
-    mutex.synchronize do
-      Worker.conditional_variable.wait(mutex, 1)
-      STDERR.puts "#{time - start}, #{current_memory}"
-    end
-  end
-end
-
-launch(TestConfiguration.iteration_count, TestConfiguration.sidekiq)
-wait_and_measure(TestConfiguration.iteration_count)