code: <R> R executeOnEndPoint(ServiceEndPoint endPoint, ServiceCallback<S, R> callback)
              throws Exception {
          ServiceHandle<S> handle = null;
  
          try {
              handle = _serviceCache.checkOut(endPoint);
  
              Timer.Context timer = _callbackExecutionTime.time();
              try {
                  return callback.call(handle.getService());
              } finally {
                  timer.stop();
              }
          } catch (NoCachedInstancesAvailableException e) {
              LOG.info("Service cache exhausted. End point: {}", endPoint, e);
              // Don't mark an end point as bad just because there are no cached end points for it.
              throw e;
          } catch (Exception e) {
              if (_serviceFactory.isRetriableException(e)) {
                  // This is a known and supported exception indicating that something went wrong somewhere in the service
                  // layer while trying to communicate with the end point.  These errors are often transient, so we
                  // enqueue a health check for the end point and mark it as unavailable for the time being.
                  markEndPointAsBad(endPoint);
                  LOG.info("Bad end point discovered. End point: {}", endPoint, e);
              }
              throw e;
          } finally {
              if (handle != null) {
                  try {
                      _serviceCache.checkIn(handle);
                  } catch (Exception e) {
                      // This should never happen, but log just in case.
                      LOG.warn("Error returning end point to cache. End point: {}, {}",
                              endPoint, e.toString());
                      LOG.debug("Exception", e);
                  }
              }
          }
      }
docs: Execute a callback on a specific end point.
  <p/>
  NOTE: This method is package private specifically so that {@link AsyncServicePool} can call it.