public InterestChannelInvoker(ClientInterestChannel delegate, Scheduler scheduler) { // TODO: add invoker metrics to the client super(SerializedTaskInvokerMetrics.dummyMetrics(), scheduler); this.delegate = delegate; }
protected STATE moveToState(STATE to) { STATE from = state.getAndSet(to); if (metrics != null) { // We do not track initState (==idle), only subsequent states that // happen when a connection is established. if (from == initState) { metrics.incrementStateCounter(to); } else { metrics.stateTransition(from, to); metrics.incrementStateCounter(to); metrics.decrementStateCounter(from); } } return from; } }
@Override public void call() { metrics.incrementOutgoingMessageCounter(message.getClass(), 1); } })
public static EurekaServerMetricFactory serverMetrics() { if (INSTANCE == null) { synchronized (EurekaServerMetricFactory.class) { MessageConnectionMetrics registrationConnectionMetrics = new MessageConnectionMetrics("registration"); registrationConnectionMetrics.bindMetrics(); MessageConnectionMetrics replicationConnectionMetrics = new MessageConnectionMetrics("replication"); replicationConnectionMetrics.bindMetrics(); MessageConnectionMetrics discoveryConnectionMetrics = new MessageConnectionMetrics("discovery"); discoveryConnectionMetrics.bindMetrics(); InterestChannelMetrics interestChannelMetrics = new InterestChannelMetrics(); interestChannelMetrics.bindMetrics(); INSTANCE = new EurekaServerMetricFactory( registrationConnectionMetrics, replicationConnectionMetrics, discoveryConnectionMetrics, interestChannelMetrics ); } } return INSTANCE; } }
public CLIENT build() { if (transportConfig == null) { transportConfig = new BasicEurekaTransportConfig.Builder().build(); } if (registryConfig == null) { registryConfig = new BasicEurekaRegistryConfig.Builder().build(); } if (clientMetricFactory == null) { clientMetricFactory = EurekaClientMetricFactory.clientMetrics(); } if (registryMetricFactory == null) { registryMetricFactory = EurekaRegistryMetricFactory.registryMetrics(); } return buildClient(); }
private void addAndSchedule(InvokerTask<?, ?> invokerTask) { boolean success = taskQueue.add(invokerTask); if (success) { queueSize.incrementAndGet(); metrics.incrementInputSuccess(); metrics.setQueueSize(queueSize.get()); } else { // needed? ConcurrentLinkedDeque never returns false for add metrics.incrementInputFailure(); } if (executorScheduled.compareAndSet(false, true)) { worker.schedule(executeAction); } }
@Override public void call() { executorScheduled.set(false); while (!taskQueue.isEmpty()) { InvokerTask<?, ?> task = taskQueue.poll(); if (task.execute()) { metrics.incrementOutputSuccess(); } else { task.cancel(); metrics.incrementOutputFailure(); } queueSize.getAndDecrement(); metrics.setQueueSize(queueSize.get()); } } };
@Override public void call() { pendingAckQueue.add(ack); metrics.incrementPendingAckCounter(); metrics.incrementOutgoingMessageCounter(message.getClass(), 1); // Connection might be closed when we serve this request, and since // pendingAckQueue and closed variables are not changed together atomically, we check // close status after adding item to pendingAckQueue, and optionally drain it. if (closed.get()) { drainPendingAckQueue(); } } })
@Override public void add(InstanceInfo instanceInfo, Source source) { queue.addLast(new EvictionItem(instanceInfo, source, worker.now() + evictionTimeoutMs)); queueSize.incrementAndGet(); evictionQueueMetrics.incrementEvictionQueueAddCounter(); evictionQueueMetrics.setEvictionQueueSize(queueSize.get()); }
public SourcedEurekaRegistryImpl(IndexRegistry<InstanceInfo> indexRegistry, EurekaRegistryMetricFactory metricsFactory, Scheduler scheduler) { this.indexRegistry = indexRegistry; this.metrics = metricsFactory.getEurekaServerRegistryMetrics(); invoker = new NotifyingInstanceInfoHolder.NotificationTaskInvoker( metricsFactory.getRegistryTaskInvokerMetrics(), scheduler); internalStore = new ConcurrentHashMap<>(); pauseableSubject = PauseableSubject.create(); internalStoreAccessor = new MultiSourcedDataHolder.HolderStoreAccessor<NotifyingInstanceInfoHolder>() { @Override public void add(NotifyingInstanceInfoHolder holder) { internalStore.put(holder.getId(), holder); metrics.setRegistrySize(internalStore.size()); } @Override public NotifyingInstanceInfoHolder get(String id) { return internalStore.get(id); } @Override public void remove(String id) { internalStore.remove(id); metrics.setRegistrySize(internalStore.size()); } @Override public boolean contains(String id) { return internalStore.containsKey(id); } }; }
/** * This method is thread safe, and it may be called concurrently. */ private void drainPendingAckQueue() { PendingAck pendingAck; while ((pendingAck = pendingAckQueue.poll()) != null) { metrics.decrementPendingAckCounter(); try { /** * TODO Although send onError here is what we should do, in current code it produces a lot misleading noise. */ pendingAck.onCompleted(); // pendingAck.onError(createException(CancellationException.class, "request cancelled")); } catch (Exception e) { logger.warn("Acknowledgement subscriber hasn't handled properly onError", e); } } }
@Override public void call(Object o) { metrics.incrementIncomingMessageCounter(o.getClass(), 1); } }).doOnTerminate(new Action0() {
public EvictionQueueImpl(long evictionTimeoutMs, EurekaRegistryMetricFactory metricFactory, Scheduler scheduler) { this.evictionTimeoutMs = evictionTimeoutMs; this.evictionQueueMetrics = metricFactory.getEvictionQueueMetrics(); this.worker = scheduler.createWorker(); this.queueSize = new AtomicInteger(0); }
private void resumeEviction() { if (selfPreservation.compareAndSet(true, false)) { metrics.setSelfPreservation(false); logger.info("Coming out of self preservation mode"); evictionSubscriber.resume(); } }
@Inject public PreservableEurekaRegistry(@Named("delegate") SourcedEurekaRegistry eurekaRegistry, EvictionQueue evictionQueue, EvictionStrategy evictionStrategy, EurekaRegistryMetricFactory metricFactory) { super(Status.UP, DESCRIPTOR); this.eurekaRegistry = eurekaRegistry; this.evictionQueue = evictionQueue; this.evictionStrategy = evictionStrategy; this.metrics = metricFactory.getEurekaServerRegistryMetrics(); this.evictionSubscriber = new EvictionSubscriber(); this.evictionSubscription = evictionQueue.pendingEvictions().subscribe(evictionSubscriber); }
protected void shutdown() { worker.unsubscribe(); while (!taskQueue.isEmpty()) { taskQueue.poll().cancel(); } metrics.setQueueSize(0); }
public BaseMessageConnection( String name, ObservableConnection<Object, Object> connection, MessageConnectionMetrics metrics, Scheduler expiryScheduler) { this.connection = connection; this.metrics = metrics; this.name = descriptiveName(name); schedulerWorker = expiryScheduler.createWorker(); installAcknowledgementHandler(); this.startTime = expiryScheduler.now(); metrics.incrementConnectionCounter(); }
public static EurekaClientMetricFactory clientMetrics() { if (INSTANCE == null) { synchronized (EurekaClientMetricFactory.class) { EurekaClientRegistryMetrics registryMetrics = new EurekaClientRegistryMetrics("client"); registryMetrics.bindMetrics(); MessageConnectionMetrics registrationServerConnectionMetrics = new MessageConnectionMetrics("clientRegistration"); registrationServerConnectionMetrics.bindMetrics(); MessageConnectionMetrics discoveryServerConnectionMetrics = new MessageConnectionMetrics("clientDiscovery"); discoveryServerConnectionMetrics.bindMetrics(); RegistrationChannelMetrics registrationChannelMetrics = new RegistrationChannelMetrics(); registrationChannelMetrics.bindMetrics(); InterestChannelMetrics interestChannelMetrics = new InterestChannelMetrics(); interestChannelMetrics.bindMetrics(); INSTANCE = new EurekaClientMetricFactory(registryMetrics, registrationServerConnectionMetrics, discoveryServerConnectionMetrics, registrationChannelMetrics, interestChannelMetrics); } } return INSTANCE; } }
protected boolean moveToState(STATE from, STATE to) { if (state.compareAndSet(from, to)) { if (metrics != null) { // We do not track initState (==idle), only subsequent states that // happen when a connection is established. if (from == initState) { metrics.incrementStateCounter(to); } else { metrics.stateTransition(from, to); metrics.incrementStateCounter(to); metrics.decrementStateCounter(from); } } return true; } return false; }
@Override public void call(Acknowledgement acknowledgement) { PendingAck pending = pendingAckQueue.poll(); metrics.decrementPendingAckCounter(); if (pending == null) { shutdown(new IllegalStateException("{connection=" + name + "}: unexpected acknowledgment")); } else { pending.ackSubject.onCompleted(); } } });