com.netflix.hystrix.metric.sample.HystrixUtilizationStream Maven / Gradle / Ivy

Go to download
/**
 * Copyright 2016 Netflix, Inc.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.netflix.hystrix.metric.sample;

import com.netflix.hystrix.HystrixCommandKey;
import com.netflix.hystrix.HystrixCommandMetrics;
import com.netflix.hystrix.HystrixThreadPoolKey;
import com.netflix.hystrix.HystrixThreadPoolMetrics;
import rx.Observable;
import rx.functions.Func0;
import rx.functions.Func1;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * This class samples current Hystrix utilization of resources and exposes that as a stream
 */
public class HystrixUtilizationStream {

    private final int intervalInMilliseconds;
    private final Observable timer;

    public HystrixUtilizationStream(final int intervalInMilliseconds) {
        this.intervalInMilliseconds = intervalInMilliseconds;
        this.timer = Observable.defer(new Func0>() {
            @Override
            public Observable call() {
                return Observable.interval(intervalInMilliseconds, TimeUnit.MILLISECONDS);
            }
        });
    }

    public Observable observe() {
        return timer.map(getAllUtilization);
    }

    public Observable> observeCommandUtilization() {
        return timer.map(getAllCommandUtilization);
    }

    public Observable> observeThreadPoolUtilization() {
        return timer.map(getAllThreadPoolUtilization);
    }

    public int getIntervalInMilliseconds() {
        return this.intervalInMilliseconds;
    }

    private static HystrixCommandUtilization sampleCommandUtilization(HystrixCommandMetrics commandMetrics) {
        return HystrixCommandUtilization.sample(commandMetrics);
    }

    private static HystrixThreadPoolUtilization sampleThreadPoolUtilization(HystrixThreadPoolMetrics threadPoolMetrics) {
        return HystrixThreadPoolUtilization.sample(threadPoolMetrics);
    }

    private static final Func1> getAllCommandUtilization =
            new Func1>() {
                @Override
                public Map call(Long timestamp) {
                    Map commandUtilizationPerKey = new HashMap();
                    for (HystrixCommandMetrics commandMetrics: HystrixCommandMetrics.getInstances()) {
                        HystrixCommandKey commandKey = commandMetrics.getCommandKey();
                        commandUtilizationPerKey.put(commandKey, sampleCommandUtilization(commandMetrics));
                    }
                    return commandUtilizationPerKey;
                }
            };

    private static final Func1> getAllThreadPoolUtilization =
            new Func1>() {
                @Override
                public Map call(Long timestamp) {
                    Map threadPoolUtilizationPerKey = new HashMap();
                    for (HystrixThreadPoolMetrics threadPoolMetrics: HystrixThreadPoolMetrics.getInstances()) {
                        HystrixThreadPoolKey threadPoolKey = threadPoolMetrics.getThreadPoolKey();
                        threadPoolUtilizationPerKey.put(threadPoolKey, sampleThreadPoolUtilization(threadPoolMetrics));
                    }
                    return threadPoolUtilizationPerKey;
                }
            };

    private static final Func1 getAllUtilization =
            new Func1() {
                @Override
                public HystrixUtilization call(Long timestamp) {
                    return HystrixUtilization.from(
                            getAllCommandUtilization.call(timestamp),
                            getAllThreadPoolUtilization.call(timestamp)
                    );
                }
            };
}