How to use

countBy

function

in

LoDashStatic

function createServicesSummary(trace) {
  const services = _.countBy(trace, span => span.serviceName);

  return _.keys(services).map(service => ({
    name: service,
    spanCount: services[service]
  }));
}

it('should execute with object and catch an error', () => {
  const error = new Error('error');
  Aigle.mixin({ countBy: _.countBy }, { override: true });
  return Aigle.countBy({ a: 0, b: 1, c: 2 }, (n) => {
   return n % 2 ? Aigle.delay(DELAY, n) : Aigle.reject(error);
  })
   .then(assert.fail)
   .catch((err) => assert.strictEqual(err, error));
 });

it('should execute with object', () => {
  Aigle.mixin({ countBy: _.countBy }, { override: true });
  const object = { a: 1.1, b: 1.4, c: 2.2 };
  return Aigle.delay(DELAY, object)
   .countBy((n) => Aigle.delay(DELAY, Math.floor(n)))
   .then((object) => assert.deepStrictEqual(object, { '1': 2, '2': 1 }));
 });

preCheckResourceLimitExceeded(functions) {
  const logGroupNames = _.flatMap(functions, (functionName) => {
   const functionObj = this.serverless.service.getFunction(functionName);

   return functionObj.events;
  }).filter(event => event.subscriptionFilter)
   .map(event => event.subscriptionFilter.logGroupName);

  _.mapKeys(_.countBy(logGroupNames), (value, key) => {
   if (value > 1) {
    const errorMessage = `
 Subscription filters of ${key} log group

 - Resource limit exceeded..

  You've hit a AWS resource limit:
  http://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch_limits_cwl.html

  Subscription filters: 1/log group. This limit cannot be changed.
    `;
    throw new this.serverless.classes.Error(errorMessage);
   }
  });
 }

const fetchFiles = async () => {
 let nextQuery = null;
 let countOfDeletedFiles = 0;
 let countOfLeavedFiles = 0;
 const timeLimit = moment()
  .add(-config.uploads.unusedImagesTimeLatency, 'ms');
 do {
  const [files, newNextQuery] = await Firebase
   .storage.getFiles(config.uploads.imagesDir, 10, nextQuery);
  nextQuery = newNextQuery;
  const results = await Promise.all(
   files.map(file => processFile(file.name, timeLimit))
  );
  const { true: _countOfDeletedFiles, false: _countOfLeavedFiles } = _.countBy(results);
  countOfLeavedFiles += _countOfLeavedFiles || 0;
  countOfDeletedFiles += _countOfDeletedFiles || 0;
 } while (nextQuery);
 log.info('processed %s files, deleted: %s, leaved: %s', countOfDeletedFiles + countOfLeavedFiles, countOfDeletedFiles, countOfLeavedFiles);
}

function getSessionStatsPerSegment(sessionsWithExtras, segmentSlug, timeScale) {
 const sessionGroups = _.groupBy(sessionsWithExtras, ({ createdAt }) =>
  getScaledTimeByTimeScale(timeScale, moment.utc(createdAt))
 )

 return _.mapValues(sessionGroups, sessions => {
  const successfulSessions = _.filter(sessions, 'isSuccessful')
  return {
   count: sessions.length,
   durationSecSum: _.sumBy(sessions, 'durationSeconds'),
   waitSecSum: _.sumBy(sessions, 'waitSeconds'),
   messageSum: _.sumBy(sessions, ({ messages }) => messages.length),
   successfulMatches: successfulSessions.length,
   'day-of-week': _.countBy(sessions, 'dayOfWeek'),
   'hour-of-day': _.countBy(sessions, 'hourOfDay'),
   topic: _.countBy(sessions, 'type'),
   'sub-topic': _.countBy(sessions, 'subTopic')
  }
 })
}

_.countBy(splittedInfo, function (n){
      return _.includes(n,'processor');
    })

_.map(_.countBy(students, 'zipCode'), (count, zipCode) => {
 if (zipCode !== 'undefined') {
  return [

const certificateCounts = _.countBy(allCertifications, _.identity)

it('should catch an error', () => {
  const error = new Error('error');
  Aigle.mixin({ countBy: _.countBy }, { override: true });
  return Aigle.countBy([0, 1, 2], (n) => {
   return n % 2 ? Aigle.delay(DELAY, n) : Aigle.reject(error);
  })
   .then(assert.fail)
   .catch((err) => assert.strictEqual(err, error));
 });