Returns {@link ClientConnectionTimings} from the specified {@link RequestLog} if exists.

@see #setTo(RequestLog)
191423
@Nullable
    public static ClientConnectionTimings get(RequestLog log) {
        requireNonNull(log, "log");
        if (log.hasAttr(TIMINGS)) {
            return log.attr(TIMINGS).get();
        }
        return null;
    }
832420
public void setConnectTimeout(int timeout) {
		Assert.isTrue(timeout >= 0, "Timeout must be a non-negative value");
		this.connectTimeout = timeout;
		setLegacyConnectionTimeout(getHttpClient(), timeout);
	}
461787
public ProxyDataSourceBuilder logSlowQueryByCommons(long thresholdTime, TimeUnit timeUnit, CommonsLogLevel logLevel, String logName) {
        this.createCommonsSlowQueryListener = true;
        this.slowQueryThreshold = thresholdTime;
        this.slowQueryTimeUnit = timeUnit;
        this.commonsSlowQueryLogLevel = logLevel;
        this.commonsSlowQueryLogName = logName;
        return this;
    }
1188973
public <R> Connection<CL> getConnectionForOperation(BaseOperation<CL, R> baseOperation) {
	return selectionStrategy.getConnection(baseOperation, cpConfiguration.getMaxTimeoutWhenExhausted(),
		TimeUnit.MILLISECONDS);
    }
1204729
@Nonnull
  public EChange setConnectionTimeoutMilliSecs (final long nMilliSecs)
  {
    if (m_nConnectionTimeoutMilliSecs == nMilliSecs)
      return EChange.UNCHANGED;
    m_nConnectionTimeoutMilliSecs = nMilliSecs;
    return EChange.CHANGED;
  }
131772
ServerMember update(Address clientAddress, Instant time) {
    if (clientAddress != null) {
      this.clientAddress = clientAddress;
      if (time.isAfter(updated)) {
        this.updated = Assert.notNull(time, "time");
      }
    }
    return this;
  }
999817
public static void setConnectionLocal(IConnection connection) {
        if (log.isDebugEnabled()) {
            log.debug("Set connection: {} with thread: {}", (connection != null ? connection.getSessionId() : null), Thread.currentThread().getName());
            try {
                StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
                StackTraceElement stackTraceElement = stackTraceElements[2];
                log.debug("Caller: {}.{} #{}", stackTraceElement.getClassName(), stackTraceElement.getMethodName(), stackTraceElement.getLineNumber());
            } catch (Exception e) {
            }
        }
        if (connection != null) {
            connThreadLocal.set(new WeakReference<IConnection>(connection));
            IScope scope = connection.getScope();
            if (scope != null) {
                Thread.currentThread().setContextClassLoader(scope.getClassLoader());
            }
        } else {
            // use null to clear the value
            connThreadLocal.remove();
        }
    }
102232
@Override
	public HttpConnection getConnectionWithTimeout(
			HostConfiguration hostConfiguration, long timeout) {

		if (httpConnection == null) {
			httpConnection = new ZapHttpConnection(hostConfiguration);
			httpConnection.setHttpConnectionManager(this);
			httpConnection.getParams().setDefaults(this.getParams());
		}
		
		return super.getConnectionWithTimeout(hostConfiguration, timeout);
	}
409407
public void doLog(String clientID, String name, long time, Level level,
			Object message, Throwable t) {
		if (logOpen && formatter != null) {
			sendMessage(syslogMessage.createMessageData(formatter.format(clientID, name, time, level, message, t)));
		}
	}
195906
public void setRequestTime(long requestTime) {

        checkFrozen();
        if (requestTime == CURRENT_TIME) {
            m_requestTime = System.currentTimeMillis();
        } else {
            m_requestTime = requestTime;
        }
    }
911012
public Moment getLastConnectionTime() {

        final ConnectionResult cr = this.result;
        return ((cr == null) ? null : cr.lastMoment);

    }
295979
@Override
    public void setConnection(RTMPConnection conn) {
        log.trace("Adding connection: {}", conn);
        int id = conn.getId();
        if (id == -1) {
            log.debug("Connection has unsupported id, using session id hash");
            id = conn.getSessionId().hashCode();
        }
        log.debug("Connection id: {} session id hash: {}", conn.getId(), conn.getSessionId().hashCode());
    }
309278
@Override
    public ConnectionMetaData getMetaData() throws JMSRuntimeException {

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "getMetaData");

        ConnectionMetaData connectionMetaData = null;
        try {
            connectionMetaData = jmsConnection.getMetaData();
        } catch (JMSException jmse) {
            throw (JMSRuntimeException) JmsErrorUtils.getJMS2Exception(jmse, JMSRuntimeException.class);
        } finally {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(this, tc, "getMetaData", new Object[] { connectionMetaData });
        }

        return connectionMetaData;
    }
573280
public OrdinalSet getConnectionSet(String connectionModel, String nodeType, int ordinal, String propertyName) {
    	int connectionModelIndex = modelHolder.getModelIndex(connectionModel);
        return getConnectionSet(connectionModelIndex, nodeType, ordinal, propertyName);
    }
1210173
protected void queueConnectForSelector(ConnectInfo connectInfo) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.entry(tc, "queueConnectForSelector");
        }

        try {
            moveIntoPosition(connectCount, connect, connectInfo, CS_CONNECTOR);
        } catch (IOException x) {
            FFDCFilter.processException(x, getClass().getName(), "140", this);
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "Caught IOException...throwing RuntimeException");
            }
            throw new RuntimeException(x);
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "queueConnectForSelector");
        }
    }
48064
@Nonnull
  public static EChange setConnectionTimeoutMilliSecs (final long nMilliSecs)
  {
    return s_aRWLock.writeLocked ( () -> {
      if (s_nConnectionTimeoutMilliSecs == nMilliSecs)
        return EChange.UNCHANGED;
      if (nMilliSecs <= 0)
        LOGGER.warn ("You are setting an indefinite connection timeout for the mail transport api: " + nMilliSecs);
      s_nConnectionTimeoutMilliSecs = nMilliSecs;
      return EChange.CHANGED;
    });
  }
565582
public ClientConnectionTimings build() {
        if (socketConnectStartTimeMicros > 0 && !socketConnectEndSet) {
            logger.warn("Should call socketConnectEnd() if socketConnectStart() was invoked.");
        }
        if (pendingAcquisitionStartTimeMicros > 0 && !pendingAcquisitionEndSet) {
            logger.warn("Should call pendingAcquisitionEnd() if pendingAcquisitionStart() was invoked.");
        }

        return new ClientConnectionTimings(
                connectionAcquisitionStartTimeMicros,
                System.nanoTime() - connectionAcquisitionStartNanos,
                dnsResolutionEndSet ? connectionAcquisitionStartTimeMicros : -1,
                dnsResolutionEndSet ? dnsResolutionEndNanos - connectionAcquisitionStartNanos : -1,
                socketConnectEndSet ? socketConnectStartTimeMicros : -1,
                socketConnectEndSet ? socketConnectEndNanos - socketConnectStartNanos : -1,
                pendingAcquisitionEndSet ? pendingAcquisitionStartTimeMicros : -1,
                pendingAcquisitionEndSet ? pendingAcquisitionEndNanos - pendingAcquisitionStartNanos : -1);
    }