How to use the oboe.drop function in oboe

self.totalParsed++;

                if (self.totalParsed > self.stopAt) {
                    emit(buffer);
                    buffer=[];
                    this.abort(); // tell oboe to shut things down
                    this.emit('end');
                } else {
                    buffer.push(point);
                    if (buffer.length >= self.limit) {
                        emit(buffer);
                        buffer = [];
                    }
                }

                return oboe.drop;
            })
            .on('end', function(){

.node('data[*]', (lesson: TimetableLesson) => {
          // Consume and discard each lesson
          lessonConsumer(lesson);
          return oboe.drop;
        })
        .done((data) => {

'features.*': feature => {
        if (!feature.geometry || !feature.geometry.type) {
          // Only add this error once
          // TODO: Give feedback on which features failed
          if (!this._errors.length) {
            this._errors.push(
              new Error(
                i18n.translate('xpack.fileUpload.patternReader.featuresOmitted', {
                  defaultMessage: 'Some features without geometry omitted',
                })
              )
            );
          }
          return oboe.drop;
        }
        return featurePatternCallback(feature);
      },
      // Handle single feature files

.on('done', function(event){
        //console.log("---------- event: ---------------------------------------------");
        //console.dir(event);
        return oboe.drop;
     })
     .on('fail', function(e){

on('node', process.env.JSON_PATH, () => {
       meter.mark();
       return oboe.drop;
    }).
    fail((err) => console.error(err.stack)).

return function(this: oboe.Oboe, node: any) {
      try {
        callback(node)
        return oboe.drop
      } catch (e) {
        winston.info(`safeOboe callback produced an error, aborting stream`, logInfo)
        this.abort()
        stream.destroy()
        reject(e)
      }
    }
  }

.node(pattern, (item) => {
            this.transform(item)
              .then(this.setNode)
              .catch(reject);
            return oboe.drop;
          })
          .done(resolve);

.node('*', function(jsonLeaf, path) {
    var nodePath = firebaseRootRef;
    for (i = 0; i < path.length; i++) { 
        nodePath = nodePath.child(path[i]);
    }
    nodePath.update(jsonLeaf);
    return oboe.drop;
  })
  .done(function(things) {

.node('stay', function(stay) {
        stay = new Stay(stay);
        stays.push(stay);

        debounceDispatch(sendStoryline());

        return oboe.drop;
      })
      .node('trip', function(trip) {

.node('segments.*', function(segment) {
      reader.push(segment);

      return oboe.drop;
    })
    .done(function() {