public enum DataErrorEnum {

    OK(200, "NONE"),
    BAD_REQUEST(400, "Server Bad Request"),
    UNAUTHORIZED(401, " Server Unauthorized"),
    SERVER_TIMEOUT(408, "Server Timeout"),
    INTERNAL_SERVER_ERROR(500, "Internal Server Error"),
    SERVERS_DOWN(6000, "Servers Down"),
    ERROR_SERVICE(6002, "Random Error Occurred on Server");

    // rest of the code
}

DataLogging.logErrors(ex, DataErrorEnum.BAD_REQUEST, keys); // if bad request
DataLogging.logErrors(ex, DataErrorEnum.UNAUTHORIZED, keys); // if unauthorized
DataLogging.logErrors(ex, DataErrorEnum.INTERNAL_SERVER_ERROR, keys); // if server error
DataLogging.logErrors(ex, DataErrorEnum.ERROR_SERVICE, keys); // if some random error occurred on server

new DataResponse(result.getBody(), DataErrorEnum.BAD_REQUEST, DataStatusEnum.ERROR)
new DataResponse(result.getBody(), DataErrorEnum.UNAUTHORIZED, DataStatusEnum.ERROR)
new DataResponse(result.getBody(), DataErrorEnum.INTERNAL_SERVER_ERROR, DataStatusEnum.ERROR)
new DataResponse(result.getBody(), DataErrorEnum.ERROR_SERVICE, DataStatusEnum.ERROR)

private AsyncRestTemplate restTemplate = new AsyncRestTemplate();

@Override
public Future<DataResponse> executeAsync(final DataKey keys) {
    final SettableFuture<DataResponse> responseFuture = SettableFuture.create();
    // for now I only have one machine in the list
    List<String> hostnames = Arrays.asList("machineA");
    executeForServers(responseFuture, keys, hostnames.get(0));
    return responseFuture;
}

private void executeForServers(final SettableFuture<DataResponse> responseFuture, final DataKey keys,
        final String hostName) {

    restTemplate.exchange(generateURL(hostName, key), HttpMethod.GET, keys.getEntity(), String.class).addCallback(
            new ListenableFutureCallback<ResponseEntity<String>>() {
                @Override
                public void onSuccess(ResponseEntity<String> result) {
                    responseFuture.set(new DataResponse(result.getBody(), DataErrorEnum.OK,
                            DataStatusEnum.SUCCESS));
                }

                // can we simplify this by making more generic?
                @Override
                public void onFailure(Throwable ex) {
                    if (ex instanceof HttpClientErrorException) {
                        HttpClientErrorException httpException = (HttpClientErrorException) ex;
                        HttpStatus statusCode = httpException.getStatusCode();
                        if (statusCode == HttpStatus.BAD_REQUEST) {
                            DataLogging.logErrors(ex, DataErrorEnum.BAD_REQUEST, keys); // if bad request
                            responseFuture.set(new DataResponse(httpException.getResponseBodyAsString(),
                                    DataErrorEnum.BAD_REQUEST, DataStatusEnum.ERROR));
                        } else if (statusCode == HttpStatus.UNAUTHORIZED) {
                            DataLogging.logErrors(ex, DataErrorEnum.UNAUTHORIZED, keys); // if unauthorized
                            responseFuture.set(new DataResponse(httpException.getResponseBodyAsString(),
                                    DataErrorEnum.UNAUTHORIZED, DataStatusEnum.ERROR));
                        } else if (statusCode == HttpStatus.REQUEST_TIMEOUT) {
                            DataLogging.logErrors(ex, DataErrorEnum.SERVER_TIMEOUT, keys); // if server timeout
                            responseFuture.set(new DataResponse(httpException.getResponseBodyAsString(),
                                    DataErrorEnum.SERVER_TIMEOUT, DataStatusEnum.ERROR));
                        } else {
                            DataLogging.logErrors(ex, DataErrorEnum.ERROR_SERVICE, keys); // some random error on server
                            responseFuture.set(new DataResponse(httpException.getResponseBodyAsString(),
                                    DataErrorEnum.ERROR_SERVICE, DataStatusEnum.ERROR));
                        }
                    } else if (ex instanceof HttpServerErrorException) {
                        HttpServerErrorException httpException = (HttpServerErrorException) ex;
                        HttpStatus statusCode = httpException.getStatusCode();

                        if (statusCode == HttpStatus.INTERNAL_SERVER_ERROR) {
                            DataLogging.logErrors(ex, DataErrorEnum.SERVER_TIMEOUT, keys); // if server error
                            responseFuture.set(new DataResponse(httpException.getResponseBodyAsString(),
                                    DataErrorEnum.SERVER_TIMEOUT, DataStatusEnum.ERROR));
                        } else {
                            DataLogging.logErrors(ex, DataErrorEnum.ERROR_SERVICE, keys); // some random error on server
                            responseFuture.set(new DataResponse(httpException.getResponseBodyAsString(),
                                    DataErrorEnum.ERROR_SERVICE, DataStatusEnum.ERROR));
                        }
                    } else if (ex instanceof RestClientException) {
                            DataLogging.logErrors(ex, DataErrorEnum.SERVERS_DOWN, keys); // server down
                            responseFuture.set(new DataResponse(null, DataErrorEnum.SERVERS_DOWN,
                                    DataStatusEnum.ERROR));
                    }
                }
            });

}