@contrast/agent 4.5.1 → 4.7.1

package/lib/assess/propagators/path/common.js

@@ -19,7 +19,6 @@ const TagRange = require('../../models/tag-range');
 const tagRangeUtil = require('../../models/tag-range/util');
 const tracker = require('../../../tracker');
 const path = require('path');
-let trackingSeparators;
 
 /**
  * Splits string by separator
@@ -31,8 +30,9 @@ let trackingSeparators;
  */
 function splitString(str, win32) {
   // windows treats both (forward and backward) slashes as separators
-  const posixRegEx = trackingSeparators ? /(?=\/)/g : /(\/)/g;
-  const win32RegEx = trackingSeparators ? /(?=[/\\])/g : /[/\\]/g;
+  const posixRegEx = /(?=\/)/g;
+  const win32RegEx = /(?=[/\\])/g;
+
   if (win32) {
     str = str.replace(/\//g, '\\').split(win32RegEx);
   } else {
@@ -55,29 +55,26 @@ function splitString(str, win32) {
  *
  * @param {Object} meta object of metadata from result/arg
  * @param {(segmentOffset: number) => boolean} meta.evaluator expression to determine the proper position of segment in string
- * @param {number} meta.offset offset of full arg from result of path.resolve
  * @param {string} meta.str result from path.resolve or arg
+ * @param {number} offset offset of full arg from result of path.resolve
  * @param {string} segment path segment from one of the args to path.resolve
  */
-function getSegmentOffset({ str, offset, evaluator }, segment, win32) {
+function getSegmentOffset({ str, evaluator }, offset, segment, win32) {
   // as the segments in each arg and in the result get traversed,
   // winnow away the string to ensure we are finding the proper
   // segment within the path
   const substr = str.substring(offset);
   let segmentOffset = substr.indexOf(segment);
   // If tracking separators, evaluator will fail on extensions
-  if (trackingSeparators && substr === `.${segment}`) {
+  if (substr === `.${segment}`) {
     return segmentOffset + offset;
   }
   // Adjust offset if the segment does not start with a separator
   const { sep } = path[win32 ? 'win32' : 'posix'];
-  if (
-    trackingSeparators &&
-    substr.startsWith(sep) &&
-    !segment.startsWith(sep)
-  ) {
+  if (substr.startsWith(sep) && !segment.startsWith(sep)) {
     segmentOffset--;
   }
+
   return evaluator(segmentOffset) ? segmentOffset + offset : -1;
 }
 
@@ -90,7 +87,12 @@ function getSegmentOffset({ str, offset, evaluator }, segment, win32) {
  */
 function isWithinTag(str, start, tag) {
   const stop = str.length - 1 + start;
-  return tag.overlaps({ start, stop, tag: tag.tag });
+
+  return (
+    (stop <= tag.stop && stop >= tag.start) ||
+    (start >= tag.start && start <= tag.stop) ||
+    (tag.start >= start && tag.start <= stop)
+  );
 }
 
 /**
@@ -103,6 +105,7 @@ function isWithinTag(str, start, tag) {
  */
 function adjustStart({ tag, argOffset, offset }) {
   const start = tag.start - argOffset;
+
   return start > 0 ? start + offset : offset;
 }
 
@@ -154,16 +157,13 @@ function maybeUpdateResultMeta({ index, arg, resultMeta }) {
 }
 
 /**
- * Encapsulates moving the resultOffset based on a segment
+ * Calculates a new offset based on a segment
  *
- * @param {Object} resultMeta metadata from result of path.resolve
- * @param {Object} argMeta metadata for a given argument
+ * @param {Object} offset offset of the object
  * @param {string} segment path segment from one of the args to path.resolve
  */
-function calculateNewOffset(resultMeta, argMeta, segment) {
-  const separatorOffset = trackingSeparators ? 0 : 1;
-  resultMeta.offset = resultMeta.offset + segment.length + separatorOffset;
-  argMeta.offset = argMeta.offset + segment.length + separatorOffset;
+function calculateNewOffset(offset, segment) {
+  return offset + segment.length;
 }
 
 /**
@@ -173,10 +173,89 @@ function calculateNewOffset(resultMeta, argMeta, segment) {
  * @param {string} segment path segment to check
  * @return {boolean}
  */
-function applicableSegment(segment) {
+function isApplicableSegment(segment) {
   return segment !== '.' && segment !== '..' && segment !== '';
 }
 
+/**
+ * Filters invalid segments like those that are not part of the end result.
+ * It also calculates additional offset.
+ *
+ * @param {*} segments splitted path into segments
+ * @param {Object} resultMeta metadata from result of path.resolve
+ * @param {Object} data the data object of the propagate function
+ * @param {number} index the iteration index
+ * @param {boolean} win32 indicating win32 to replace `/` with `\'
+ */
+function filterSegmentsAndCalculateOffset(
+  segments,
+  resultMeta,
+  data,
+  index,
+  win32
+) {
+  const { sep } = path[win32 ? 'win32' : 'posix'];
+  const isFirstIteration = index === 0;
+  const validSegments = [];
+  let additionalOffset = 0;
+
+  segments.reduce(
+    // eslint-disable-next-line complexity
+    (accumulator, segment) => {
+      let hasChange = false;
+      if (!isApplicableSegment(segment)) return accumulator;
+
+      if (!accumulator.isModified && !isFirstIteration) {
+        const previousArg = data.args[index - 1];
+
+        const sepAdded = !segment.startsWith(sep) && !previousArg.endsWith(sep);
+        const sepTaken = segment.startsWith(sep) && previousArg.endsWith(sep);
+        accumulator.isModified = sepAdded || sepTaken;
+        hasChange = sepAdded || sepTaken;
+        additionalOffset = hasChange ? (sepAdded ? 1 : -1) : 0;
+      }
+
+      const offset = getSegmentOffset(
+        resultMeta,
+        accumulator.offset + additionalOffset + accumulator.fileDotSeparator,
+        segment,
+        win32
+      );
+
+      // no reason to proceed if segment is not in final result
+      if (offset === -1) {
+        if (hasChange) {
+          additionalOffset = 0;
+          accumulator.isModified = false;
+        }
+
+        return accumulator;
+      }
+
+      // in case we have a file we need to increment the offset
+      if (resultMeta.str[offset + segment.length] === '.') {
+        accumulator.fileDotSeparator = 1;
+      }
+
+      validSegments.push(segment);
+      accumulator.offset = calculateNewOffset(accumulator.offset, segment);
+      accumulator.isModified = true;
+
+      return accumulator;
+    },
+    {
+      offset: resultMeta.offset,
+      fileDotSeparator: 0,
+      isModified: false
+    }
+  );
+
+  return {
+    additionalOffset,
+    segments: validSegments
+  };
+}
+
 /**
  * Moves the tag ranges properly based on if a path segment exists in the
  * result
@@ -184,43 +263,66 @@ function applicableSegment(segment) {
  * @param {Object} resultMeta metadata for the result
  * @param {Object} argMeta meta for a given argument
  * @param {boolean} win32 indicating win32 to replace `/` with `\'
+ * @param {Object} data the data object of the propagate function
+ * @param {number} index the iteration index
  */
-function adjustTagsToPart(resultMeta, argMeta, win32) {
+function adjustTagsToPart(resultMeta, argMeta, win32, data, index) {
   const { str, tagRanges } = argMeta;
-  const segments = splitString(str, win32);
-  const newTags = [];
-  segments.forEach((segment) => {
-    if (!applicableSegment(segment)) {
-      return;
-    }
-    const offset = getSegmentOffset(resultMeta, segment, win32);
-    // no reason to proceed if segment is not in final result
-    if (offset === -1) {
-      return;
-    }
+  const { segments, additionalOffset } = filterSegmentsAndCalculateOffset(
+    splitString(str, win32),
+    resultMeta,
+    data,
+    index,
+    win32
+  );
+
+  // updating the offset
+  resultMeta.offset += additionalOffset;
+
+  return segments.reduce((newTags, segment) => {
+    const offset = getSegmentOffset(
+      resultMeta,
+      resultMeta.offset,
+      segment,
+      win32
+    );
+
+    const argOffset = getSegmentOffset(argMeta, argMeta.offset, segment, win32);
 
-    const argOffset = getSegmentOffset(argMeta, segment, win32);
+    // updating the offset
+    resultMeta.offset = calculateNewOffset(resultMeta.offset, segment);
+    argMeta.offset = calculateNewOffset(argMeta.offset, segment);
 
-    calculateNewOffset(resultMeta, argMeta, segment);
+    // in case we have a file we need to increment the offset
+    if (resultMeta.str[offset + segment.length] === '.') {
+      resultMeta.offset += 1;
+    }
 
     tagRanges.forEach((tag) => {
-      if (isWithinTag(segment, argOffset, tag)) {
-        const start = adjustStart({ tag, argOffset, offset });
-        const stop = adjustStop({ tag, argOffset, offset, segment });
+      if (!isWithinTag(segment, argOffset, tag)) return;
 
-        newTags.push(new TagRange(start, stop, tag.tag));
-      }
+      const start = adjustStart({
+        tag,
+        argOffset,
+        offset
+      });
+      const stop = adjustStop({
+        tag,
+        argOffset,
+        offset,
+        segment
+      });
+
+      newTags.push(new TagRange(start, stop, tag.tag));
     });
-  });
 
-  return newTags;
+    return newTags;
+  }, []);
 }
 
-function propagate({ resultMeta, data, win32, trackSeparators }) {
-  trackingSeparators = trackSeparators;
+function propagate({ resultMeta, data, win32 }) {
   if (!resultMeta.evaluator) {
-    resultMeta.evaluator = (segmentOffset) =>
-      segmentOffset === (trackingSeparators ? 0 : 1);
+    resultMeta.evaluator = (segmentOffset) => segmentOffset === 0;
   }
 
   data.args.forEach((arg, index) => {
@@ -231,16 +333,23 @@ function propagate({ resultMeta, data, win32, trackSeparators }) {
       evaluator: (segmentOffset) => segmentOffset > -1,
       offset: 0,
       str: arg,
-      tagRanges: argData.tracked ? argData.tagRanges : []
+      tagRanges: argData ? argData.tagRanges : []
     };
 
-    const targetTagRanges = adjustTagsToPart(resultMeta, argMeta, win32);
+    const targetTagRanges = adjustTagsToPart(
+      resultMeta,
+      argMeta,
+      win32,
+      data,
+      index
+    );
 
     if (targetTagRanges.length > 0) {
       resultMeta.parents.push(argData.event);
       tagRangeUtil.addAllInPlace(resultMeta.tagRanges, targetTagRanges);
     }
   });
+
   trackResult(resultMeta, data);
 }
 

package/lib/assess/propagators/path/dirname.js

@@ -42,7 +42,7 @@ module.exports.handle = function handle() {
           if (!data.args[0]) return;
 
           const trackingData = tracker.getData(data.args[0]);
-          if (!trackingData.tracked) return;
+          if (!trackingData) return;
 
           // path.dirname() does a slice at 0 to the calculated end separator
           const tagRanges = createSubsetTagRanges({
@@ -57,19 +57,20 @@ module.exports.handle = function handle() {
 
           if (!tagRanges.length) return;
 
-          const result = tracker.track(data.result);
-          const resultData = tracker.getData(result);
+          const tracked = tracker.track(data.result);
           const parentEvent = trackingData.event;
-          resultData.tagRanges = tagRanges;
-          resultData.event = new PropagationEvent({
-            context: new CallContext(data),
-            parents: [parentEvent],
-            signature,
-            source: 'P',
-            tagRanges,
-            target: 'R'
-          });
-          data.result = result;
+          if (tracked) {
+            tracked.props.tagRanges = tagRanges;
+            tracked.props.event = new PropagationEvent({
+              context: new CallContext(data),
+              parents: [parentEvent],
+              signature,
+              source: 'P',
+              tagRanges,
+              target: 'R'
+            });
+            data.result = tracked.str;  
+          }
         }
       });
     }

package/lib/assess/propagators/path/extname.js

@@ -42,7 +42,7 @@ module.exports.handle = function handle() {
           if (!data.args[0] || !data.result) return;
 
           const trackingData = tracker.getData(data.args[0]);
-          if (!trackingData.tracked) return;
+          if (!trackingData) return;
 
           // The path.extname() implementation does a substr on the argument
           // based on the calculated index of the last dot
@@ -62,19 +62,20 @@ module.exports.handle = function handle() {
           // no tags propagated to the result
           if (!tagRanges.length) return;
 
-          const result = tracker.track(data.result);
-          const resultData = tracker.getData(result);
+          const tracked = tracker.track(data.result);
           const parentEvent = trackingData.event;
-          resultData.tagRanges = tagRanges;
-          resultData.event = new PropagationEvent({
-            context: new CallContext(data),
-            parents: [parentEvent],
-            signature,
-            source: 'P',
-            tagRanges,
-            target: 'R'
-          });
-          data.result = result;
+          if (tracked) {
+            tracked.props.tagRanges = tagRanges;
+            tracked.props.event = new PropagationEvent({
+              context: new CallContext(data),
+              parents: [parentEvent],
+              signature,
+              source: 'P',
+              tagRanges,
+              target: 'R'
+            });
+            data.result = tracked.str;  
+          }
         }
       });
     }

package/lib/assess/propagators/path/join.js

@@ -31,7 +31,11 @@ function hookPath(path) {
           resultMeta.offset = 0;
           resultMeta.evaluator = (segmentOffset) => segmentOffset === 0;
         }
-        propagate({ data, resultMeta, win32: os === 'win32' });
+        propagate({
+          data,
+          resultMeta,
+          win32: os === 'win32'
+        });
       }
     });
   }

package/lib/assess/propagators/path/normalize.js

@@ -46,8 +46,7 @@ module.exports.handle = function handle() {
           propagate({
             resultMeta,
             data,
-            win32: os === 'win32',
-            trackSeparators: true
+            win32: os === 'win32'
           });
         }
       });

package/lib/assess/propagators/path/parse.js

@@ -24,7 +24,7 @@ const propagate = function propagate(data) {
   const props = tracker.getData(data.args[0]);
   const { result } = data;
 
-  if (props.tracked && result) {
+  if (props && result) {
     const membrane = new DeserializationMembrane(data, props);
     data.result = membrane.wrap(result);
   }

package/lib/assess/propagators/path/relative.js

@@ -35,7 +35,7 @@ const provider = {
     const { args, result } = data;
     const trackData = tracker.getData(args[1]);
 
-    if (!trackData.tracked) {
+    if (!trackData) {
       return;
     }
 
@@ -61,10 +61,12 @@ const provider = {
         },
         data
       );
-      data.result = tracker.track(data.result);
-      const resultTrackData = tracker.getData(data.result);
-      resultTrackData.tagRanges = shiftedRanges;
-      resultTrackData.event = event;
+      const tracked = tracker.track(data.result);
+      if (tracked) {
+        data.result = tracked.str;
+        tracked.props.tagRanges = shiftedRanges;
+        tracked.props.event = event;
+      }
     }
   },
   /**

package/lib/assess/propagators/path/resolve.js

@@ -34,7 +34,12 @@ module.exports.handle = function handle() {
           if (!data.args[0]) return;
           const resultMeta = getResultMeta(data, 'resolve');
           const isAbsolute = absolutePath(data.args[0]);
-          resultMeta.offset = isAbsolute ? 0 : process.cwd().length;
+
+          /*
+            plus one in case isAbsolute is false since our working deretory ends without slash
+            example: /Users/John/Documents/Projects/node-agent
+          */
+          resultMeta.offset = isAbsolute ? 0 : process.cwd().length + 1;
 
           // a work-around for paths like C:\Windows
           if (
@@ -45,7 +50,11 @@ module.exports.handle = function handle() {
             resultMeta.evaluator = (segmentOffset) => segmentOffset > -1;
           }
 
-          propagate({ data, resultMeta, win32: os === 'win32' });
+          propagate({
+            data,
+            resultMeta,
+            win32: os === 'win32'
+          });
         }
       });
     }

package/lib/assess/propagators/querystring/escape.js

@@ -21,34 +21,36 @@ const qsUtils = require('./utils');
 
 function handler(data) {
   const input = data.args[0];
+  const trackedData = tracker.getData(input);
 
-  if (!input || !tracker.getData(input).tracked) {
+  if (!input || !trackedData) {
     return;
   }
 
   // adjust tag ranges
   const tagRanges = [];
-  tracker.getData(input).tagRanges.forEach((tag) => {
+  trackedData.tagRanges.forEach((tag) => {
     tagRanges.push(qsUtils.adjustRangeEscape(tag, 0, input));
   });
   tagRanges.push(new TagRange(0, data.result.length - 1, 'url-encoded'));
 
-  const result = tracker.track(data.result);
-  const trackData = tracker.getData(result);
-  trackData.tagRanges = tagRanges;
-  trackData.event = new PropagationEvent({
-    context: new CallContext({
-      ...data,
-      obj: null
-    }),
-    parents: [trackData.event],
-    signature: new Signature('querystring.escape'),
-    source: 'P',
-    target: 'R',
-    tagRanges,
-    tags: ['url-encoded']
-  });
-  data.result = result;
+  const tracked = tracker.track(data.result);
+  if (tracked) {
+    tracked.props.tagRanges = tagRanges;
+    tracked.props.event = new PropagationEvent({
+      context: new CallContext({
+        ...data,
+        obj: null
+      }),
+      parents: [tracked.props.event],
+      signature: new Signature('querystring.escape'),
+      source: 'P',
+      target: 'R',
+      tagRanges,
+      tags: ['url-encoded']
+    });
+    data.result = tracked.str;
+  }
 }
 
 module.exports.handle = handler;

package/lib/assess/propagators/querystring/parse.js

@@ -47,9 +47,11 @@ function getUnescapeWrapper(data, unescape) {
 
     // track the part w/ trimmed ranges if applicable
     if (tagRanges.length) {
-      result = tracker.track(part);
-      resultData = tracker.getData(result);
-      resultData.tagRanges = tagRanges;
+      const tracked = tracker.track(part);
+      if (tracked) {
+        result = tracked.str;
+        tracked.props.tagRanges = tagRanges;
+      }
     } else {
       result = part;
     }
@@ -58,7 +60,7 @@ function getUnescapeWrapper(data, unescape) {
     result = Scopes.runInAllowAllScope(() => unescape(result));
     resultData = tracker.getData(result);
 
-    if (resultData.tracked) {
+    if (resultData) {
       resultData.event = new PropagationEvent({
         context: new CallContext({
           ...data,
@@ -91,7 +93,7 @@ function pre(data) {
   }
   const trackingData = tracker.getData(input);
 
-  if (!trackingData.tracked) {
+  if (!trackingData) {
     return;
   }
 

package/lib/assess/propagators/querystring/stringify.js

@@ -129,7 +129,7 @@ class OnEscapeHandler {
     // set current key for reference if when array-valued
     this.currentKey = {
       value: escaped,
-      tagRanges: trackingData.tracked ? trackingData.tagRanges : null
+      tagRanges: trackingData ? trackingData.tagRanges : null
     };
 
     // capture track info before updating state
@@ -175,7 +175,7 @@ class OnEscapeHandler {
       this.offset += this.currentKey.value.length + this.eqLen;
     }
 
-    if (trackingData.tracked) {
+    if (trackingData) {
       ret.push({
         offset: this.offset,
         tagRanges: trackingData.tagRanges,
@@ -279,34 +279,35 @@ function post(data) {
   }
 
   const tracked = tracker.track(data.result);
-  const trackData = tracker.getData(tracked);
 
   if (data.state.escape === querystring.escape) {
     data.state.tagRanges.push(
       new TagRange(0, data.result.length - 1, 'url-encoded')
     );
   }
-  const sorted = _.sortBy(data.state.tagRanges, 'start');
-  trackData.tagRanges = [];
-  tagRangeUtil.addAllInPlace(trackData.tagRanges, sorted);
-
-  // stringify / encode
-  const method = data.funcKey.split('.')[1];
-
-  trackData.event = new PropagationEvent({
-    context: new CallContext({
-      ...data,
-      args: data.state.origArgs,
-      obj: null
-    }),
-    parents: Array.from(data.state.events),
-    signature: new Signature(`querystring.${method}`),
-    source: 'P',
-    tagRanges: trackData.tagRanges,
-    target: 'R',
-    tags: ['url-encoded']
-  });
-  data.result = tracked;
+  if (tracked) {
+    const sorted = _.sortBy(data.state.tagRanges, 'start');
+    tracked.props.tagRanges = [];
+    tagRangeUtil.addAllInPlace(tracked.props.tagRanges, sorted);
+  
+    // stringify / encode
+    const method = data.funcKey.split('.')[1];
+  
+    tracked.props.event = new PropagationEvent({
+      context: new CallContext({
+        ...data,
+        args: data.state.origArgs,
+        obj: null
+      }),
+      parents: Array.from(data.state.events),
+      signature: new Signature(`querystring.${method}`),
+      source: 'P',
+      tagRanges: tracked.props.tagRanges,
+      target: 'R',
+      tags: ['url-encoded']
+    });
+    data.result = tracked.str;
+  }
 }
 
 module.exports.handle = { pre, post };