Circuit breaker for this command key

@return CircuitBreaker
422949
private function getCircuitBreaker()
    {
        return $this->circuitBreakerFactory->get($this->getCommandKey(), $this->config, $this->getMetrics());
    }
342299
public function enableCommandName()
    {
        if (!$this->commandNameEnabled
            && $this->commandName
            && isset($this->arguments[0])
            && $this->arguments[0] === $this->commandName
        ) {
            unset($this->arguments[0]);
            $this->arguments = array_values($this->arguments);
        }
        $this->commandNameEnabled = true;
        return $this;
    }
387841
function trip(item, ctx) {
		item.state = C.CIRCUIT_OPEN;
		item.ep.state = false;

		if (item.cbTimer) {
			clearTimeout(item.cbTimer);
			item.cbTimer = null;
		}

		item.cbTimer = setTimeout(() => halfOpen(item, ctx), item.opts.halfOpenTime);
		item.cbTimer.unref();

		const rate = item.count > 0 ? item.failures / item.count : 0;
		logger.debug(`Circuit breaker has been opened on '${item.ep.name}' endpoint.`, { nodeID: item.ep.id, action: item.ep.action.name, failures: item.failures, count: item.count, rate });
		broker.broadcast("$circuit-breaker.opened", { nodeID: item.ep.id, action: item.ep.action.name, failures: item.failures, count: item.count, rate });
	}
1324032
private function getStdin()
    {
        if (!isset($this->stdin)) {
            $this->stdin = \fopen('php://stdin', 'r');
        }

        if (\feof($this->stdin)) {
            throw new BreakException('Ctrl+D');
        }

        return $this->stdin;
    }
657987
public function build(): SetBreakpointByUrlRequest
	{
		$instance = new SetBreakpointByUrlRequest();
		if ($this->lineNumber === null) {
			throw new BuilderException('Property [lineNumber] is required.');
		}
		$instance->lineNumber = $this->lineNumber;
		$instance->url = $this->url;
		$instance->urlRegex = $this->urlRegex;
		$instance->scriptHash = $this->scriptHash;
		$instance->columnNumber = $this->columnNumber;
		$instance->condition = $this->condition;
		return $instance;
	}
569429
public function get($commandKey, Config $commandConfig, CommandMetrics $metrics)
    {
        if (!isset($this->circuitBreakersByCommand[$commandKey])) {
            $circuitBreakerConfig = $commandConfig->get('circuitBreaker');
            if ($circuitBreakerConfig->get('enabled')) {
                $this->circuitBreakersByCommand[$commandKey] =
                    new CircuitBreaker($commandKey, $metrics, $commandConfig, $this->stateStorage);
            } else {
                $this->circuitBreakersByCommand[$commandKey] = new NoOpCircuitBreaker();
            }
        }

        return $this->circuitBreakersByCommand[$commandKey];
    }
117716
public function build(): SetEventListenerBreakpointRequest
	{
		$instance = new SetEventListenerBreakpointRequest();
		if ($this->eventName === null) {
			throw new BuilderException('Property [eventName] is required.');
		}
		$instance->eventName = $this->eventName;
		$instance->targetName = $this->targetName;
		return $instance;
	}
1032531
public static CircuitBreakerExports ofCircuitBreaker(String prefix, CircuitBreaker circuitBreaker) {
        requireNonNull(prefix);
        requireNonNull(circuitBreaker);
        return new CircuitBreakerExports(prefix, Array.of(circuitBreaker));
    }
258955
public function obtainLock()
    {
        $tries       = 0;
        $waitClosure = $this->getWaitClosure();
        do {
            if ($this->doLock()->isLocked()) {
                return $this;
            }

            ++$tries;
            $waitClosure();
        } while ($tries < $this->lockTry);

        return $this;
    }
516775
public function build(): SetBreakpointsActiveRequest
	{
		$instance = new SetBreakpointsActiveRequest();
		if ($this->active === null) {
			throw new BuilderException('Property [active] is required.');
		}
		$instance->active = $this->active;
		return $instance;
	}
1234467
public function build(): RemoveBreakpointRequest
	{
		$instance = new RemoveBreakpointRequest();
		if ($this->breakpointId === null) {
			throw new BuilderException('Property [breakpointId] is required.');
		}
		$instance->breakpointId = $this->breakpointId;
		return $instance;
	}
658705
public final SecretKey generateKey() {
        if (serviceIterator == null) {
            return spi.engineGenerateKey();
        }
        RuntimeException failure = null;
        KeyGeneratorSpi mySpi = spi;
        do {
            try {
                return mySpi.engineGenerateKey();
            } catch (RuntimeException e) {
                if (failure == null) {
                    failure = e;
                }
                mySpi = nextSpi(mySpi, true);
            }
        } while (mySpi != null);
        throw failure;
   }
703698
public function destroy()
    {
        $keys = [];

        foreach ($this->rows as $key => $row) {
            if ($this->rowStateIsNew($key)) {
                continue;
            }

            $keys[] = $this->rowFirstUnique($row);

            $this->markRowAsNew($key);
        }

        if ($keys) {
            [$sql, $params] = $this->newDeleteQuery()->where($this->firstUniqueKey(), $keys)->toSql();

            $this->connection()->sqlExecute($sql, $params);
        }

        return $this;
    }
535640
public static Function<Client<RpcRequest, RpcResponse>, CircuitBreakerRpcClient>
    newDecorator(CircuitBreakerMapping mapping, CircuitBreakerStrategyWithContent<RpcResponse> strategy) {
        return delegate -> new CircuitBreakerRpcClient(delegate, mapping, strategy);
    }
242458
public CircuitBreakerBean findCircuitBreakerBean(String name) {
        CircuitBreaker circuitBreaker = findCircuitBreaker(name);

        if (circuitBreaker instanceof CircuitBreakerBean) {
            return (CircuitBreakerBean) circuitBreaker;
        }
        return null;
    }
561772
public CircuitGroupUnblockingAckMessage createCGUA() {

        CircuitGroupUnblockingAckMessage msg = new CircuitGroupUnblockingAckMessageImpl(_CGUA_HOLDER.mandatoryCodes,
                _CGUA_HOLDER.mandatoryVariableCodes, _CGUA_HOLDER.optionalCodes, _CGUA_HOLDER.mandatoryCodeToIndex,
                _CGUA_HOLDER.mandatoryVariableCodeToIndex, _CGUA_HOLDER.optionalCodeToIndex);

        return msg;
    }
140027
private function _break() {
    $node = new BreakStatementNode();
    $this->mustMatch(T_BREAK, $node);
    if ($this->tryMatch(';', $node, NULL, TRUE, TRUE) || $this->currentType === T_CLOSE_TAG) {
      return $node;
    }
    $this->parseLevel($node);
    $this->endStatement($node);
    return $node;
  }