com.uber.jaeger.samplers.RemoteControlledSampler Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jaeger-core Show documentation
Jaeger Java bindings for OpenTracing API
There is a newer version: 0.27.0
/*
 * Copyright (c) 2016, Uber Technologies, Inc
 *
 * 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.
 */
package com.uber.jaeger.samplers;

import com.uber.jaeger.exceptions.SamplingStrategyErrorException;
import com.uber.jaeger.exceptions.UnknownSamplingStrategyException;
import com.uber.jaeger.metrics.Metrics;
import com.uber.jaeger.thrift.sampling_manager.ProbabilisticSamplingStrategy;
import com.uber.jaeger.thrift.sampling_manager.RateLimitingSamplingStrategy;
import com.uber.jaeger.thrift.sampling_manager.SamplingStrategyResponse;

import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.locks.ReentrantReadWriteLock;

@SuppressWarnings("EqualsHashCode")
public class RemoteControlledSampler implements Sampler {
  public static final String TYPE = "remote";

  private final String serviceName;
  private final SamplingManager manager;
  private final Timer pollTimer;
  private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
  private Sampler sampler;
  private Metrics metrics;

  public RemoteControlledSampler(
      String serviceName, SamplingManager manager, Sampler initial, Metrics metrics) {
    final int pollingIntervalMs = 60000;
    this.serviceName = serviceName;
    this.manager = manager;
    this.metrics = metrics;

    if (initial != null) {
      this.sampler = initial;
    } else {
      this.sampler = new ProbabilisticSampler(0.001);
    }

    pollTimer = new Timer(true); // true makes this a daemon thread
    pollTimer.schedule(
        new TimerTask() {
          @Override
          public void run() {
            updateSampler();
          }
        },
        0,
        pollingIntervalMs);
  }

  public ReentrantReadWriteLock getLock() {
    return lock;
  }

  private void updateSampler() {
    SamplingStrategyResponse response;
    try {
      response = manager.getSamplingStrategy(serviceName);
      metrics.samplerRetrieved.inc(1);
    } catch (SamplingStrategyErrorException e) {
      metrics.samplerQueryFailure.inc(1);

      return;
    }

    Sampler newSampler;
    try {
      newSampler = extractSampler(response);
    } catch (UnknownSamplingStrategyException e) {
      metrics.samplerParsingFailure.inc(1);
      return; // sampler updateGauge without a new sampler
    }

    if (!this.sampler.equals(newSampler)) {
      synchronized (this) {
        this.sampler = newSampler;
        metrics.samplerUpdated.inc(1);
      }
    }
  }

  private Sampler extractSampler(SamplingStrategyResponse response)
      throws UnknownSamplingStrategyException {
    if (response.isSetProbabilisticSampling()) {
      ProbabilisticSamplingStrategy strategy = response.getProbabilisticSampling();
      return new ProbabilisticSampler(strategy.getSamplingRate());
    }

    if (response.isSetRateLimitingSampling()) {
      RateLimitingSamplingStrategy strategy = response.getRateLimitingSampling();
      return new RateLimitingSampler(strategy.getMaxTracesPerSecond());
    }

    throw new UnknownSamplingStrategyException(
        String.format("Unsupported sampling strategy type %s", response.getStrategyType()));
  }

  @Override
  public boolean isSampled(long id) {
    synchronized (this) {
      return sampler.isSampled(id);
    }
  }

  @Override
  public Map getTags() {
    synchronized (this) {
      return sampler.getTags();
    }
  }

  @Override
  public boolean equals(Object sampler) {
    if (this == sampler) return true;
    if (sampler instanceof RemoteControlledSampler) {
      RemoteControlledSampler remoteSampler = ((RemoteControlledSampler) sampler);
      synchronized (this) {
        ReentrantReadWriteLock.ReadLock readLock = remoteSampler.getLock().readLock();
        readLock.lock();
        try {
          return this.sampler.equals(remoteSampler.sampler);
        } finally {
          readLock.unlock();
        }
      }
    }
    return false;
  }

  @Override
  public void close() {
    synchronized (this) {
      pollTimer.cancel();
    }
  }
}