Examples with RandomEngine cern.jet.random.engine.RandomEngine used on opensource projects

Example 6 with RandomEngine

use of cern.jet.random.engine.RandomEngine in project micrometer by micrometer-metrics.

the class TimerMaximumThroughputSample method main.

public static void main(String[] args) {
    MeterRegistry registry = SampleConfig.myMonitoringSystem();
    Timer timer = Timer.builder("timer").publishPercentileHistogram().sla(Duration.ofMillis(275), Duration.ofMillis(300), Duration.ofMillis(500)).distributionStatisticExpiry(Duration.ofSeconds(10)).distributionStatisticBufferLength(3).register(registry);
    RandomEngine r = new MersenneTwister64(0);
    Normal duration = new Normal(250, 50, r);
    AtomicInteger latencyForThisSecond = new AtomicInteger(duration.nextInt());
    Flux.interval(Duration.ofSeconds(1)).doOnEach(d -> latencyForThisSecond.set(duration.nextInt())).subscribe();
    Stream<Integer> infiniteStream = Stream.iterate(0, i -> (i + 1) % 1000);
    Flux.fromStream(infiniteStream).parallel(4).runOn(Schedulers.parallel()).doOnEach(d -> timer.record(latencyForThisSecond.get(), TimeUnit.MILLISECONDS)).subscribe();
    Flux.never().blockLast();
}

Example 7 with RandomEngine

use of cern.jet.random.engine.RandomEngine in project micrometer by micrometer-metrics.

the class TimerSample method main.

public static void main(String[] args) {
    MeterRegistry registry = SampleConfig.myMonitoringSystem();
    Timer timer = Timer.builder("timer").publishPercentileHistogram().publishPercentiles(0.5, 0.95, 0.99).sla(Duration.ofMillis(275), Duration.ofMillis(300), Duration.ofMillis(500)).distributionStatisticExpiry(Duration.ofSeconds(10)).distributionStatisticBufferLength(3).register(registry);
    FunctionTimer.builder("ftimer", timer, Timer::count, t -> t.totalTime(TimeUnit.SECONDS), TimeUnit.SECONDS).register(registry);
    RandomEngine r = new MersenneTwister64(0);
    Normal incomingRequests = new Normal(0, 1, r);
    Normal duration = new Normal(250, 50, r);
    AtomicInteger latencyForThisSecond = new AtomicInteger(duration.nextInt());
    Flux.interval(Duration.ofSeconds(1)).doOnEach(d -> latencyForThisSecond.set(duration.nextInt())).subscribe();
    // the potential for an "incoming request" every 10 ms
    Flux.interval(Duration.ofMillis(10)).doOnEach(d -> {
        if (incomingRequests.nextDouble() + 0.4 > 0) {
            // pretend the request took some amount of time, such that the time is
            // distributed normally with a mean of 250ms
            timer.record(latencyForThisSecond.get(), TimeUnit.MILLISECONDS);
        }
    }).blockLast();
}

Example 8 with RandomEngine

use of cern.jet.random.engine.RandomEngine in project micrometer by micrometer-metrics.

the class FunctionTimerSample method main.

// For Atlas: http://localhost:7101/api/v1/graph?q=name,ftimer,:eq,:dist-avg,name,timer,:eq,:dist-avg,1,:axis&s=e-5m&l=0
public static void main(String[] args) {
    MeterRegistry registry = SampleConfig.myMonitoringSystem();
    Timer timer = Timer.builder("timer").publishPercentiles(0.5, 0.95).register(registry);
    Object placeholder = new Object();
    AtomicLong totalTimeNanos = new AtomicLong(0);
    AtomicLong totalCount = new AtomicLong(0);
    FunctionTimer.builder("ftimer", placeholder, p -> totalCount.get(), p -> totalTimeNanos.get(), TimeUnit.NANOSECONDS).register(registry);
    RandomEngine r = new MersenneTwister64(0);
    Normal incomingRequests = new Normal(0, 1, r);
    Normal duration = new Normal(250, 50, r);
    AtomicInteger latencyForThisSecond = new AtomicInteger(duration.nextInt());
    Flux.interval(Duration.ofSeconds(1)).doOnEach(d -> latencyForThisSecond.set(duration.nextInt())).subscribe();
    // the potential for an "incoming request" every 10 ms
    Flux.interval(Duration.ofMillis(10)).doOnEach(d -> {
        if (incomingRequests.nextDouble() + 0.4 > 0) {
            // pretend the request took some amount of time, such that the time is
            // distributed normally with a mean of 250ms
            timer.record(latencyForThisSecond.get(), TimeUnit.MILLISECONDS);
            totalCount.incrementAndGet();
            totalTimeNanos.addAndGet((long) TimeUtils.millisToUnit(latencyForThisSecond.get(), TimeUnit.NANOSECONDS));
        }
    }).blockLast();
}

Example 9 with RandomEngine

use of cern.jet.random.engine.RandomEngine in project micrometer by micrometer-metrics.

the class LongTaskTimerSample method main.

public static void main(String[] args) {
    MeterRegistry registry = SampleConfig.myMonitoringSystem();
    LongTaskTimer timer = registry.more().longTaskTimer("longTaskTimer");
    RandomEngine r = new MersenneTwister64(0);
    Normal incomingRequests = new Normal(0, 1, r);
    Normal duration = new Normal(30, 50, r);
    AtomicInteger latencyForThisSecond = new AtomicInteger(duration.nextInt());
    Flux.interval(Duration.ofSeconds(1)).doOnEach(d -> latencyForThisSecond.set(duration.nextInt())).subscribe();
    final Map<LongTaskTimer.Sample, CountDownLatch> tasks = new ConcurrentHashMap<>();
    // the potential for an "incoming request" every 10 ms
    Flux.interval(Duration.ofSeconds(1)).doOnEach(d -> {
        if (incomingRequests.nextDouble() + 0.4 > 0 && tasks.isEmpty()) {
            int taskDur;
            while ((taskDur = duration.nextInt()) < 0) ;
            synchronized (tasks) {
                tasks.put(timer.start(), new CountDownLatch(taskDur));
            }
        }
        synchronized (tasks) {
            for (Map.Entry<LongTaskTimer.Sample, CountDownLatch> e : tasks.entrySet()) {
                e.getValue().countDown();
                if (e.getValue().getCount() == 0) {
                    e.getKey().stop();
                    tasks.remove(e.getKey());
                }
            }
        }
    }).blockLast();
}

Example 10 with RandomEngine

use of cern.jet.random.engine.RandomEngine in project micrometer by micrometer-metrics.

the class SimulatedEndpointInstrumentation method main.

public static void main(String[] args) {
    MeterRegistry registry = SampleConfig.myMonitoringSystem();
    Timer e1Success = Timer.builder("http.server.requests").tags("uri", "/api/bar").tags("response", "200").publishPercentiles(0.5, 0.95).register(registry);
    Timer e2Success = Timer.builder("http.server.requests").tags("uri", "/api/foo").tags("response", "200").publishPercentiles(0.5, 0.95).register(registry);
    Timer e1Fail = Timer.builder("http.server.requests").tags("uri", "/api/bar").tags("response", "500").publishPercentiles(0.5, 0.95).register(registry);
    Timer e2Fail = Timer.builder("http.server.requests").tags("uri", "/api/foo").tags("response", "500").publishPercentiles(0.5, 0.95).register(registry);
    RandomEngine r = new MersenneTwister64(0);
    Normal incomingRequests = new Normal(0, 1, r);
    Normal successOrFail = new Normal(0, 1, r);
    Normal duration = new Normal(250, 50, r);
    Normal duration2 = new Normal(250, 50, r);
    AtomicInteger latencyForThisSecond = new AtomicInteger(duration.nextInt());
    Flux.interval(Duration.ofSeconds(1)).doOnEach(d -> latencyForThisSecond.set(duration.nextInt())).subscribe();
    AtomicInteger latencyForThisSecond2 = new AtomicInteger(duration2.nextInt());
    Flux.interval(Duration.ofSeconds(1)).doOnEach(d -> latencyForThisSecond2.set(duration2.nextInt())).subscribe();
    // the potential for an "incoming request" every 10 ms
    Flux.interval(Duration.ofMillis(10)).doOnEach(d -> {
        // are we going to receive a request for /api/foo?
        if (incomingRequests.nextDouble() + 0.4 > 0) {
            if (successOrFail.nextDouble() + 0.8 > 0) {
                // pretend the request took some amount of time, such that the time is
                // distributed normally with a mean of 250ms
                e1Success.record(latencyForThisSecond.get(), TimeUnit.MILLISECONDS);
            } else {
                e1Fail.record(latencyForThisSecond.get(), TimeUnit.MILLISECONDS);
            }
        }
    }).subscribe();
    // the potential for an "incoming request" every 1 ms
    Flux.interval(Duration.ofMillis(1)).doOnEach(d -> {
        // are we going to receive a request for /api/bar?
        if (incomingRequests.nextDouble() + 0.4 > 0) {
            if (successOrFail.nextDouble() + 0.8 > 0) {
                // pretend the request took some amount of time, such that the time is
                // distributed normally with a mean of 250ms
                e2Success.record(latencyForThisSecond2.get(), TimeUnit.MILLISECONDS);
            } else {
                e2Fail.record(latencyForThisSecond2.get(), TimeUnit.MILLISECONDS);
            }
        }
    }).blockLast();
}