track this and pass it downstream for source mapping.
15672
function write(token, enc, next) {
    var type = token[0], buf = token[1];
    
    if(('rule_start' === type || 'atrule_start' === type))
      depth++;
    if(depth > 0 && !current)
      current = {location: [line, column], buffers:[]};
    if('rule_end' === type || 'atrule_end' === type)
      depth--;
    
    if(current) {
      current.buffers.push(buf);
      if(depth === 0) pushRule.call(this);
    }
    
    updatePosition(buf);
    next();
  }
732492
@Deprecated
    private void onStepProgress(Object source)
    {
        onStartStepProgress(null, source);

        // if there is only one step close it and move to the next one
        if (this.currentStep.getParent().getChildren().size() == 1) {
            this.currentStep = this.currentStep.getParent().nextStep(null, source);
        }
    }
759833
def set_source(self, source):
        """"""
        route = Navigator(source=self.source).navigate_to_source(source)

        # Save new source
        self.source = source

        return self._send_keystroke(route, wait=True)
1198961
function() {
		gui.TrackerPlugin.prototype.onconstruct.call(this);
		this.context = self; // TODO: deprecate this whole thing...
		this._watches = [];
		this._matches = [];
		this._needing = [];
	}
326918
public function actionTrack(): void
	{
		if ($this->getPost('leave')) {
			$this->tracking->leave();
		}
		if ($this->getPost('url')) {
			$this->tracking->track();
		}
		$this->terminate();
	}
76280
def process(self, metric):
        
        if self._match_metric(metric):
            self.metrics.append(metric)
        if self.should_flush():
            self._send()
743354
def trace_on (full=False):
    """"""
    if full:
        sys.settrace(_trace_full)
    else:
        sys.settrace(_trace)
235785
def backtrack(self, source):
        """"""
        key = self.get_tok(source)
        s = self[key]()
        meta = s.metadata['original_source']
        cls = meta['cls']
        args = meta['args']
        kwargs = meta['kwargs']
        cls = import_name(cls)
        sout = cls(*args, **kwargs)
        sout.metadata = s.metadata['original_metadata']
        sout.name = s.metadata['original_name']
        return sout
602293
private void trackNestedMapping(OngoingMappings ongoingMappings) {
        for (ResourceModelMetaData metaData : ongoingMappings.getMetaData()) {
            metaData.getStatistics().countSubsequentMapping();
        }
    }
881889
def _track(self, class_name):
        """"""
        if self._test_cases.get(class_name) is None:
            if self.streaming and self.header:
                self._write_test_case_header(class_name, self.stream)

            self._test_cases[class_name] = []
            if self.combined:
                self.combined_test_cases_seen.append(class_name)
90386
void endPass(String passName) {
    checkState(currentTracer != null, "Tracer should not be null at the end of a pass.");
    stopTracer(currentTracer, currentPassName);
    afterPass(passName);
    currentPassName = null;
    currentTracer = null;

    maybeRunValidityCheck();
  }
537406
function() {
            if (observed.size) {
                observed.forEach(performPropertyChecks);
                handlers.forEach(deliverHandlerRecords);
                nextFrame(runGlobalLoop);
            }
        }
245064
def process_streamers(self):
        """"""

        # Check for any triggered streamers and pass them to stream manager
        in_progress = self._stream_manager.in_progress()
        triggered = self.graph.check_streamers(blacklist=in_progress)

        for streamer in triggered:
            self._stream_manager.process_streamer(streamer, callback=self._handle_streamer_finished)
460771
def handle_output(self, workunit, label, stream):
    """"""

    self._root_id_to_workunit_stack[str(workunit.root().id)][-1]['outputs'][label] += stream
665553
function follow (cid, links, err, obj) {
      if (err) {
        return cb(err)
      }

      if (!links.length) {
        // done tracing, obj is the target node
        return cb(null, cid.buffer)
      }

      const linkName = links[0]
      const nextObj = obj.links.find(link => link.name === linkName)
      if (!nextObj) {
        return cb(new Error(
          `no link named "${linkName}" under ${cid.toBaseEncodedString()}`
        ))
      }

      objectAPI.get(nextObj.cid, follow.bind(null, nextObj.cid, links.slice(1)))
    }
207411
private void done()
   {
      if (longThreadPool != null && isLong)
      {
         transport.updateLongRunningFree(address,
                                         longThreadPool.getNumberOfFreeThreads() + 1);
      }
      else
      {
         transport.updateShortRunningFree(address,
                                          shortThreadPool.getNumberOfFreeThreads() + 1);
      }
   }
643369
def handle_fork(self):
        
        self.reset()
        self.sensor.handle_fork()
        instana.singletons.tracer.handle_fork()