diff --git a/src/ui/public/courier/fetch/call_response_handlers.js b/src/ui/public/courier/fetch/call_response_handlers.js
index 94972fde9f2058..13b0dcc81e728a 100644
--- a/src/ui/public/courier/fetch/call_response_handlers.js
+++ b/src/ui/public/courier/fetch/call_response_handlers.js
@@ -26,40 +26,40 @@ export function CallResponseHandlersProvider(Private, Promise) {
   const ABORTED = RequestStatus.ABORTED;
   const INCOMPLETE = RequestStatus.INCOMPLETE;
 
-  function callResponseHandlers(requests, responses) {
-    return Promise.map(requests, function (req, i) {
-      if (req === ABORTED || req.aborted) {
+  function callResponseHandlers(searchRequests, responses) {
+    return Promise.map(searchRequests, function (searchRequest, index) {
+      if (searchRequest === ABORTED || searchRequest.aborted) {
         return ABORTED;
       }
 
-      const resp = responses[i];
+      const response = responses[index];
 
-      if (resp.timed_out) {
+      if (response.timed_out) {
         courierNotifier.warning(new SearchTimeout());
       }
 
-      if (resp._shards && resp._shards.failed) {
-        courierNotifier.warning(new ShardFailure(resp));
+      if (response._shards && response._shards.failed) {
+        courierNotifier.warning(new ShardFailure(response));
       }
 
       function progress() {
-        if (req.isIncomplete()) {
+        if (searchRequest.isIncomplete()) {
           return INCOMPLETE;
         }
 
-        req.complete();
-        return resp;
+        searchRequest.complete();
+        return response;
       }
 
-      if (resp.error) {
-        if (req.filterError(resp)) {
+      if (response.error) {
+        if (searchRequest.filterError(response)) {
           return progress();
         } else {
-          return req.handleFailure(new RequestFailure(null, resp));
+          return searchRequest.handleFailure(new RequestFailure(null, response));
         }
       }
 
-      return Promise.try(() => req.handleResponse(resp)).then(progress);
+      return Promise.try(() => searchRequest.handleResponse(response)).then(progress);
     });
   }
 
diff --git a/src/ui/public/courier/fetch/continue_incomplete.js b/src/ui/public/courier/fetch/continue_incomplete.js
index cca5fde71adfe8..b40ebdb8867487 100644
--- a/src/ui/public/courier/fetch/continue_incomplete.js
+++ b/src/ui/public/courier/fetch/continue_incomplete.js
@@ -22,21 +22,26 @@ import { RequestStatus } from './req_status';
 export function ContinueIncompleteProvider() {
   const INCOMPLETE = RequestStatus.INCOMPLETE;
 
-  function continueIncompleteRequests(requests, responses, fetchSearchResults) {
-    const incomplete = [];
+  function continueIncompleteRequests(searchRequests, responses, fetchSearchResults) {
+    const incompleteSearchRequests = [];
 
-    responses.forEach(function (resp, i) {
-      if (resp === INCOMPLETE) {
-        incomplete.push(requests[i]);
+    responses.forEach(function (response, index) {
+      if (response === INCOMPLETE) {
+        incompleteSearchRequests.push(searchRequests[index]);
       }
     });
 
-    if (!incomplete.length) return responses;
+    if (!incompleteSearchRequests.length) {
+      return responses;
+    }
 
-    return fetchSearchResults(incomplete)
+    return fetchSearchResults(incompleteSearchRequests)
       .then(function (completedResponses) {
         return responses.map(function (prevResponse) {
-          if (prevResponse !== INCOMPLETE) return prevResponse;
+          if (prevResponse !== INCOMPLETE) {
+            return prevResponse;
+          }
+
           return completedResponses.shift();
         });
       });
diff --git a/src/ui/public/courier/fetch/fetch_now.js b/src/ui/public/courier/fetch/fetch_now.js
index 8a35949b5f49af..73a670100cecee 100644
--- a/src/ui/public/courier/fetch/fetch_now.js
+++ b/src/ui/public/courier/fetch/fetch_now.js
@@ -45,32 +45,41 @@ export function FetchNowProvider(Private, Promise) {
   const DUPLICATE = RequestStatus.DUPLICATE;
   const INCOMPLETE = RequestStatus.INCOMPLETE;
 
-  function fetchNow(requests) {
-    return fetchSearchResults(requests.map(function (req) {
-      if (!req.started) return req;
-      return req.retry();
+  function fetchNow(searchRequests) {
+    return fetchSearchResults(searchRequests.map(function (searchRequest) {
+      if (!searchRequest.started) {
+        return searchRequest;
+      }
+
+      return searchRequest.retry();
     }))
       .catch(error => fatalError(error, location));
   }
 
-  function fetchSearchResults(requests) {
+  function fetchSearchResults(searchRequests) {
     function replaceAbortedRequests() {
-      requests = requests.map(r => r.aborted ? ABORTED : r);
+      searchRequests = searchRequests.map(searchRequest => {
+        if (searchRequest.aborted) {
+          return ABORTED;
+        }
+
+        return searchRequest;
+      });
     }
 
     replaceAbortedRequests();
-    return startRequests(requests)
+    return startRequests(searchRequests)
       .then(function () {
         replaceAbortedRequests();
-        return callClient(requests);
+        return callClient(searchRequests);
       })
       .then(function (responses) {
         replaceAbortedRequests();
-        return callResponseHandlers(requests, responses);
+        return callResponseHandlers(searchRequests, responses);
       })
       .then(function (responses) {
         replaceAbortedRequests();
-        return continueIncomplete(requests, responses, fetchSearchResults);
+        return continueIncomplete(searchRequests, responses, fetchSearchResults);
       })
       .then(function (responses) {
         replaceAbortedRequests();
@@ -88,17 +97,17 @@ export function FetchNowProvider(Private, Promise) {
       });
   }
 
-  function startRequests(requests) {
-    return Promise.map(requests, function (req) {
-      if (req === ABORTED) {
-        return req;
+  function startRequests(searchRequests) {
+    return Promise.map(searchRequests, function (searchRequest) {
+      if (searchRequest === ABORTED) {
+        return searchRequest;
       }
 
       return new Promise(function (resolve) {
-        const action = req.started ? req.continue : req.start;
-        resolve(action.call(req));
+        const action = searchRequest.started ? searchRequest.continue : searchRequest.start;
+        resolve(action.call(searchRequest));
       })
-        .catch(err => req.handleFailure(err));
+        .catch(err => searchRequest.handleFailure(err));
     });
   }