Reverting TSVB calculate_auto; fixing names in infra

simianhacker · simianhacker · commit de2310522dfd · 2020-08-12T15:53:32.000-07:00
diff --git a/src/plugins/vis_type_timeseries/server/lib/vis_data/helpers/calculate_auto.js b/src/plugins/vis_type_timeseries/server/lib/vis_data/helpers/calculate_auto.js
@@ -41,23 +41,23 @@ const roundingRules = [
 
 const revRoundingRules = roundingRules.slice(0).reverse();
 
-function findRule(rules, check, last) {
-  function pickBucket(buckets, duration) {
+function find(rules, check, last) {
+  function pick(buckets, duration) {
     const target = duration / buckets;
-    let lastResult = null;
+    let lastResp = null;
 
     for (let i = 0; i < rules.length; i++) {
       const rule = rules[i];
-      const result = check(rule[0], rule[1], target);
+      const resp = check(rule[0], rule[1], target);
 
-      if (result == null) {
+      if (resp == null) {
         if (!last) continue;
-        if (lastResult) return lastResult;
+        if (lastResp) return lastResp;
         break;
       }
 
-      if (!last) return result;
-      lastResult = result;
+      if (!last) return resp;
+      lastResp = resp;
     }
 
     // fallback to just a number of milliseconds, ensure ms is >= 1
@@ -66,25 +66,25 @@ function findRule(rules, check, last) {
   }
 
   return (buckets, duration) => {
-    const interval = pickBucket(buckets, duration);
+    const interval = pick(buckets, duration);
     if (interval) return moment.duration(interval._data);
   };
 }
 
 export const calculateAuto = {
-  near: findRule(
+  near: find(
     revRoundingRules,
     function near(bound, interval, target) {
       if (bound > target) return interval;
     },
     true
   ),
 
-  lessThan: findRule(revRoundingRules, function lessThan(_bound, interval, target) {
+  lessThan: find(revRoundingRules, function lessThan(_bound, interval, target) {
     if (interval < target) return interval;
   }),
 
-  atLeast: findRule(revRoundingRules, function atLeast(_bound, interval, target) {
+  atLeast: find(revRoundingRules, function atLeast(_bound, interval, target) {
     if (interval <= target) return interval;
   }),
 };
diff --git a/x-pack/plugins/infra/server/lib/metrics/lib/calculate_bucket_size/calculate_auto.ts b/x-pack/plugins/infra/server/lib/metrics/lib/calculate_bucket_size/calculate_auto.ts
@@ -39,22 +39,22 @@ type CheckFunction = (
   target: number
 ) => Duration | undefined;
 
-function find(rules: Rule[], check: CheckFunction, last?: boolean) {
-  function pick(buckets: number, duration: Duration) {
+function findRule(rules: Rule[], check: CheckFunction, last?: boolean) {
+  function pickInterval(buckets: number, duration: Duration) {
     const target = duration.asMilliseconds() / buckets;
-    let lastResp = null;
+    let lastResult = null;
 
     for (const rule of rules) {
-      const resp = check(rule[0] as Duration, rule[1] as Duration, target);
+      const result = check(rule[0] as Duration, rule[1] as Duration, target);
 
-      if (resp == null) {
+      if (result == null) {
         if (!last) continue;
-        if (lastResp) return lastResp;
+        if (lastResult) return lastResult;
         break;
       }
 
-      if (!last) return resp;
-      lastResp = resp;
+      if (!last) return result;
+      lastResult = result;
     }
 
     // fallback to just a number of milliseconds, ensure ms is >= 1
@@ -63,13 +63,13 @@ function find(rules: Rule[], check: CheckFunction, last?: boolean) {
   }
 
   return (buckets: number, duration: Duration) => {
-    const interval = pick(buckets, duration);
+    const interval = pickInterval(buckets, duration);
     if (isDuration(interval)) return interval;
   };
 }
 
 export const calculateAuto = {
-  near: find(
+  near: findRule(
     revRoundingRules,
     function near(bound, interval, target) {
       if (isDuration(bound) && bound.asMilliseconds() > target) return interval;
@@ -78,11 +78,11 @@ export const calculateAuto = {
     true
   ),
 
-  lessThan: find(revRoundingRules, function lessThan(_bound, interval, target) {
+  lessThan: findRule(revRoundingRules, function lessThan(_bound, interval, target) {
     if (interval.asMilliseconds() < target) return interval;
   }),
 
-  atLeast: find(revRoundingRules, function atLeast(_bound, interval, target) {
+  atLeast: findRule(revRoundingRules, function atLeast(_bound, interval, target) {
     if (interval.asMilliseconds() <= target) return interval;
   }),
 };
