import com.netflix.servo.monitor.Monitors; //导入依赖的package包/类
private static RepeatingActivity initServo(Exhibitor exhibitor, ActivityLog log, ActivityQueue activityQueue, ExhibitorArguments arguments, AtomicReference<CompositeMonitor<?>> theMonitor)
{
    theMonitor.set(null);

    RepeatingActivity localServoMonitoring = null;
    if ( arguments.servoRegistration != null )
    {
        ZookeeperMonitoredData  zookeeperMonitoredData = new ZookeeperMonitoredData();
        CompositeMonitor<?>     compositeMonitor = Monitors.newObjectMonitor(zookeeperMonitoredData);

        GetMonitorData          getMonitorData = new GetMonitorData(exhibitor, zookeeperMonitoredData);
        localServoMonitoring = new RepeatingActivityImpl(log, activityQueue, QueueGroups.IO, getMonitorData, arguments.servoRegistration.getZookeeperPollMs());
        arguments.servoRegistration.getMonitorRegistry().register(compositeMonitor);

        theMonitor.set(compositeMonitor);
    }
    return localServoMonitoring;
}
 

import com.netflix.servo.monitor.Monitors; //导入依赖的package包/类
/**
 * Start the plugin.
 */
public void start() {
    if (!config.isEnabled()) {
        LOGGER.info("Atlas Plugin is disabled.");
        return;
    }

    final List<MetricPoller> pollers = Lists.newArrayList();
    final MonitorRegistry registry = DefaultMonitorRegistry.getInstance();
    final MetricPoller poller = new MonitorRegistryMetricPoller(registry);
    pollers.add(poller);

    final MetricPoller jvmPoller = new JvmMetricPoller();
    pollers.add(jvmPoller);

    thePoller = new CompositePoller(pollers);
    final long delayForMainPoller = delaySecondsFor(Pollers.getPollingIntervals().get(0));
    addPoller(thePoller, delayForMainPoller, TimeUnit.SECONDS);
    registry.register(Monitors.newObjectMonitor(observer));

    LOGGER.info("Starting to keep track of the cpu usage for threads in the jvm.");
    ThreadCpuStats.getInstance().start();
    LOGGER.info("Atlas Plugin started.");
}
 

import com.netflix.servo.monitor.Monitors; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean(AbstractLoadBalancerAwareClient.class)
@ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
public RetryableOkHttpLoadBalancingClient okHttpLoadBalancingClient(
	IClientConfig config,
	ServerIntrospector serverIntrospector,
	ILoadBalancer loadBalancer,
	RetryHandler retryHandler,
	LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory,
	OkHttpClient delegate,
	LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory,
	LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory) {
	RetryableOkHttpLoadBalancingClient client = new RetryableOkHttpLoadBalancingClient(delegate, config,
			serverIntrospector, loadBalancedRetryPolicyFactory, loadBalancedBackOffPolicyFactory, loadBalancedRetryListenerFactory);
	client.setLoadBalancer(loadBalancer);
	client.setRetryHandler(retryHandler);
	Monitors.registerObject("Client_" + this.name, client);
	return client;
}
 

import com.netflix.servo.monitor.Monitors; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean(AbstractLoadBalancerAwareClient.class)
@ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
public RetryableRibbonLoadBalancingHttpClient retryableRibbonLoadBalancingHttpClient(
	IClientConfig config, ServerIntrospector serverIntrospector,
	ILoadBalancer loadBalancer, RetryHandler retryHandler,
	LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory, CloseableHttpClient httpClient,
	LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory,
	LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory) {
	RetryableRibbonLoadBalancingHttpClient client = new RetryableRibbonLoadBalancingHttpClient(
		httpClient, config, serverIntrospector, loadBalancedRetryPolicyFactory,
		loadBalancedBackOffPolicyFactory, loadBalancedRetryListenerFactory);
	client.setLoadBalancer(loadBalancer);
	client.setRetryHandler(retryHandler);
	Monitors.registerObject("Client_" + this.name, client);
	return client;
}
 

import com.netflix.servo.monitor.Monitors; //导入依赖的package包/类
@Override
public void initWithNiwsConfig(IClientConfig niwsClientConfig) {
    String sZoneAffinity = "" + niwsClientConfig.getProperty(CommonClientConfigKey.EnableZoneAffinity, false);
    if (sZoneAffinity != null){
        zoneAffinity = Boolean.parseBoolean(sZoneAffinity);
        logger.debug("ZoneAffinity is set to {}", zoneAffinity);
    }
    String sZoneExclusive = "" + niwsClientConfig.getProperty(CommonClientConfigKey.EnableZoneExclusivity, false);
    if (sZoneExclusive != null){
        zoneExclusive = Boolean.parseBoolean(sZoneExclusive);
    }
    if (ConfigurationManager.getDeploymentContext() != null) {
        zone = ConfigurationManager.getDeploymentContext().getValue(ContextKey.zone);
    }
    activeReqeustsPerServerThreshold = DynamicPropertyFactory.getInstance().getDoubleProperty(niwsClientConfig.getClientName() + "." + niwsClientConfig.getNameSpace() + ".zoneAffinity.maxLoadPerServer", 0.6d);
    logger.debug("activeReqeustsPerServerThreshold: {}", activeReqeustsPerServerThreshold.get());
    blackOutServerPercentageThreshold = DynamicPropertyFactory.getInstance().getDoubleProperty(niwsClientConfig.getClientName() + "." + niwsClientConfig.getNameSpace() + ".zoneAffinity.maxBlackOutServesrPercentage", 0.8d);
    logger.debug("blackOutServerPercentageThreshold: {}", blackOutServerPercentageThreshold.get());
    availableServersThreshold = DynamicPropertyFactory.getInstance().getIntProperty(niwsClientConfig.getClientName() + "." + niwsClientConfig.getNameSpace() + ".zoneAffinity.minAvailableServers", 2);
    logger.debug("availableServersThreshold: {}", availableServersThreshold.get());
    overrideCounter = Monitors.newCounter("ZoneAffinity_OverrideCounter");

    Monitors.registerObject("NIWSServerListFilter_" + niwsClientConfig.getClientName());
}
 

import com.netflix.servo.monitor.Monitors; //导入依赖的package包/类
/**
 * Set necessary parameters from client configuration and register with Servo monitors.
 */
@Override
public void initWithNiwsConfig(IClientConfig clientConfig) {
    if (clientConfig == null) {
        return;    
    }
    clientName = clientConfig.getClientName();
    if (clientName == null) {
        clientName = "default";
    }
    vipAddresses = clientConfig.resolveDeploymentContextbasedVipAddresses();
    maxAutoRetries = clientConfig.getPropertyAsInteger(CommonClientConfigKey.MaxAutoRetries, DefaultClientConfigImpl.DEFAULT_MAX_AUTO_RETRIES);
    maxAutoRetriesNextServer = clientConfig.getPropertyAsInteger(CommonClientConfigKey.MaxAutoRetriesNextServer,maxAutoRetriesNextServer);

    okToRetryOnAllOperations = clientConfig.getPropertyAsBoolean(CommonClientConfigKey.OkToRetryOnAllOperations, okToRetryOnAllOperations);
    defaultRetryHandler = new DefaultLoadBalancerRetryHandler(clientConfig);
    
    tracer = getExecuteTracer();

    Monitors.registerObject("Client_" + clientName, this);
}
 

import com.netflix.servo.monitor.Monitors; //导入依赖的package包/类
private void setUp(String name, int maxRetries, 
        long maxTotalTimeToPrimeConnections, String primeConnectionsURI, float primeRatio) {        
    this.name = name;
    this.maxRetries = maxRetries;
    this.maxTotalTimeToPrimeConnections = maxTotalTimeToPrimeConnections;
    this.primeConnectionsURIPath = primeConnectionsURI;        
    this.primeRatio = primeRatio;
    executorService = new ThreadPoolExecutor(1 /* minimum */,
            maxExecutorThreads /* max threads */,
            executorThreadTimeout /*
                                   * timeout - same property as create
                                   * timeout
                                   */, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<Runnable>()
            /* Bounded queue with FIFO- bounded to max tasks */,
            new ASyncPrimeConnectionsThreadFactory(name) /*
                                                          * So we can give
                                                          * our Thread a
                                                          * name
                                                          */
    );        
    totalCounter = Monitors.newCounter(name + "_PrimeConnection_TotalCounter");
    successCounter = Monitors.newCounter(name + "_PrimeConnection_SuccessCounter");
    initialPrimeTimer = Monitors.newTimer(name + "_initialPrimeConnectionsTimer", TimeUnit.MILLISECONDS);
    Monitors.registerObject(name + "_PrimeConnection", this);
}
 

import com.netflix.servo.monitor.Monitors; //导入依赖的package包/类
/**
 *
 * @param config Client configuration
 * @param lb LoadBalancer implementation
 */
@Inject
public ConnectionPool(ClientConfig config, ILoadBalancer lb) {
    this.config = config;
    this.lb = lb;

    connectionSweeper = Executors.newScheduledThreadPool(1);
    newConnectionBuilder = Executors.newFixedThreadPool(1);

    Monitors.registerObject(this);

    populationLatch = new CountDownLatch(Math.min(lb.getServerList(true).size(), config.getAsyncSenderThreads()));
    Executors.newSingleThreadExecutor().submit(new Runnable() {
        @Override
        public void run() {
            populateClients();
        }
    });
    try {
        populationLatch.await(populationLatch.getCount() * config.getConnectionTimeout(), TimeUnit.MILLISECONDS);
    } catch (InterruptedException e) {
        logger.error("Exception on CountDownLatch awaiting: " + e.getMessage(), e);
    }
    logger.info("ConnectionPool population finished with the size: " + getPoolSize()
            + ", will continue up to: " + lb.getServerList(true).size());
}
 

import com.netflix.servo.monitor.Monitors; //导入依赖的package包/类
public RemoteFileSink(
        LocalFileSink localFileSink,
        RemotePrefixFormatter prefixFormatter,
        int concurrentUpload,
        boolean batchUpload) {
    this.localFileSink = localFileSink;
    this.prefixFormatter = prefixFormatter == null ? new DynamicRemotePrefixFormatter("date(yyyyMMdd)") : prefixFormatter;
    this.batchUpload = batchUpload;

    Preconditions.checkNotNull(localFileSink, "localFileSink is needed");

    uploader = Executors.newFixedThreadPool(concurrentUpload == 0 ? 5 : concurrentUpload);
    localFilePoller = Executors.newSingleThreadExecutor();

    if (!batchUpload) {
        localFileSink.cleanUp(false);
    }

    Monitors.registerObject(
            this.getClass().getSimpleName() + '-' + localFileSink.getOutputDir().replace('/', '_'),
            this);
}
 

import com.netflix.servo.monitor.Monitors; //导入依赖的package包/类
private void setupMonitoring(boolean shutdown) {
    try {
        final ObjectName mBeanName = ObjectName.getInstance("com.netflix.evcache:Group=" + appName
                + ",SubGroup=pool,SubSubGroup=" + serverGroup.getName() + ",SubSubSubGroup=" + id);
        final MBeanServer mbeanServer = ManagementFactory.getPlatformMBeanServer();
        if (mbeanServer.isRegistered(mBeanName)) {
            if (log.isDebugEnabled()) log.debug("MBEAN with name " + mBeanName
                    + " has been registered. Will unregister the previous instance and register a new one.");
            mbeanServer.unregisterMBean(mBeanName);
        }
        if (!shutdown) {
            mbeanServer.registerMBean(this, mBeanName);
            Monitors.registerObject(this);
        } else {
            Monitors.unregisterObject(this);
        }
    } catch (Exception e) {
        if (log.isWarnEnabled()) log.warn(e.getMessage(), e);
    }
}
 

import com.netflix.servo.monitor.Monitors; //导入依赖的package包/类
private void setupMonitoring() {
    try {
        final ObjectName mBeanName = ObjectName.getInstance("com.netflix.evcache:Group=" + _appName
                + ",SubGroup=pool");
        final MBeanServer mbeanServer = ManagementFactory.getPlatformMBeanServer();
        if (mbeanServer.isRegistered(mBeanName)) {
            if (log.isDebugEnabled()) log.debug("MBEAN with name " + mBeanName
                    + " has been registered. Will unregister the previous instance and register a new one.");
            mbeanServer.unregisterMBean(mBeanName);
        }
        if (!_shutdown) {
            mbeanServer.registerMBean(this, mBeanName);
            Monitors.registerObject(this);
        } else {
            Monitors.unregisterObject(this);
        }
    } catch (Exception e) {
        if (log.isDebugEnabled()) log.debug("Exception", e);
    }
}
 

import com.netflix.servo.monitor.Monitors; //导入依赖的package包/类
public static DistributionSummary getDistributionSummary(String name, String appName, String serverGroup) {
    final String metricName = getMetricName(appName, serverGroup, name);
    final DistributionSummary _ds = distributionSummaryMap.get(metricName);
    if(_ds != null) return _ds;
    final Registry registry = Spectator.globalRegistry(); //_poolManager.getRegistry();
    if (registry != null) {
        Id id = registry.createId(name);
        id = id.withTag("owner", "evcache");
        id = id.withTag("APP", appName);
        if(serverGroup != null) id = id.withTag("ServerGroup", serverGroup);
        final DistributionSummary ds = registry.distributionSummary(id);
        if (!Monitors.isObjectRegistered(ds)) Monitors.registerObject(ds);
        distributionSummaryMap.put(metricName, ds);
        return ds;
    }
    return null;
}
 

import com.netflix.servo.monitor.Monitors; //导入依赖的package包/类
public DynoCPMonitor(String namePrefix) {
	
	try {
		DefaultMonitorRegistry.getInstance().register(Monitors.newObjectMonitor(namePrefix, this));
	} catch (Exception e) {
		Logger.warn("Failed to register metrics with monitor registry", e);
	}
}
 

import com.netflix.servo.monitor.Monitors; //导入依赖的package包/类
@Inject
public HealthMonitor(IConfiguration config, InstanceManager instanceManager, HttpModule httpModule) {
    super(config);
    this.instanceManager = instanceManager;
    this.httpModule = httpModule;
    healthReporter = new Elasticsearch_HealthReporter();
    discoveryClient = DiscoveryManager.getInstance().getDiscoveryClient();
    Monitors.registerObject(healthReporter);
}
 

import com.netflix.servo.monitor.Monitors; //导入依赖的package包/类
@Inject
public SnapshotBackupMonitor(IConfiguration config, SnapshotBackupManager snapshotBackupManager) {
    super(config);
    snapshotBackupReporter = new Elasticsearch_SnapshotBackupReporter();
    this.snapshotBackupManager = snapshotBackupManager;
    Monitors.registerObject(snapshotBackupReporter);
}
 

import com.netflix.servo.monitor.Monitors; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean(AbstractLoadBalancerAwareClient.class)
@ConditionalOnMissingClass(value = "org.springframework.retry.support.RetryTemplate")
public OkHttpLoadBalancingClient retryableOkHttpLoadBalancingClient(
	IClientConfig config,
	ServerIntrospector serverIntrospector, ILoadBalancer loadBalancer,
	RetryHandler retryHandler, OkHttpClient delegate) {
	OkHttpLoadBalancingClient client = new OkHttpLoadBalancingClient(delegate, config,
			serverIntrospector);
	client.setLoadBalancer(loadBalancer);
	client.setRetryHandler(retryHandler);
	Monitors.registerObject("Client_" + this.name, client);
	return client;
}
 

import com.netflix.servo.monitor.Monitors; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean(AbstractLoadBalancerAwareClient.class)
@ConditionalOnMissingClass(value = "org.springframework.retry.support.RetryTemplate")
public RibbonLoadBalancingHttpClient ribbonLoadBalancingHttpClient(
	IClientConfig config, ServerIntrospector serverIntrospector,
	ILoadBalancer loadBalancer, RetryHandler retryHandler, CloseableHttpClient httpClient) {
	RibbonLoadBalancingHttpClient client = new RibbonLoadBalancingHttpClient(httpClient, config, serverIntrospector);
	client.setLoadBalancer(loadBalancer);
	client.setRetryHandler(retryHandler);
	Monitors.registerObject("Client_" + this.name, client);
	return client;
}
 

import com.netflix.servo.monitor.Monitors; //导入依赖的package包/类
/**
 * Create a Netflix {@link RestClient} integrated with Ribbon if none already exists
 * in the application context. It is not required for Ribbon to work properly and is
 * therefore created lazily if ever another component requires it.
 *
 * @param config             the configuration to use by the underlying Ribbon instance
 * @param loadBalancer       the load balancer to use by the underlying Ribbon instance
 * @param serverIntrospector server introspector to use by the underlying Ribbon instance
 * @param retryHandler       retry handler to use by the underlying Ribbon instance
 * @return a {@link RestClient} instances backed by Ribbon
 */
@Bean
@Lazy
@ConditionalOnMissingBean(AbstractLoadBalancerAwareClient.class)
public RestClient ribbonRestClient(IClientConfig config, ILoadBalancer loadBalancer,
								   ServerIntrospector serverIntrospector, RetryHandler retryHandler) {
	RestClient client = new RibbonClientConfiguration.OverrideRestClient(config, serverIntrospector);
	client.setLoadBalancer(loadBalancer);
	client.setRetryHandler(retryHandler);
	Monitors.registerObject("Client_" + this.name, client);
	return client;
}
 

import com.netflix.servo.monitor.Monitors; //导入依赖的package包/类
public static void shutdownNFHttpClient(String name) {
    NFHttpClient c = namedClientMap.get(name);
    if (c != null) {
        c.shutdown();
        namedClientMap.remove(name);
        Monitors.unregisterObject(name, c);
    }
}
 

import com.netflix.servo.monitor.Monitors; //导入依赖的package包/类
void initMonitors(String name) {
    Preconditions.checkNotNull(name);
    freeEntryCounter = Monitors.newCounter(name + "_Reuse");
    createEntryCounter = Monitors.newCounter(name + "_CreateNew");
    requestCounter = Monitors.newCounter(name + "_Request");
    releaseCounter = Monitors.newCounter(name + "_Release");
    deleteCounter = Monitors.newCounter(name + "_Delete");
    requestTimer = Monitors.newTimer(name + "_RequestConnectionTimer", TimeUnit.MILLISECONDS);
    creationTimer = Monitors.newTimer(name + "_CreateConnectionTimer", TimeUnit.MILLISECONDS);
    this.name = name;
    Monitors.registerObject(name, this);
}