Run results for: Rule Benchmark

Test name	Executions per second
VERBOSE (1)	1846.0 Ops/sec
VERBOSE (2)	457.0 Ops/sec
INFO (1)	825.6 Ops/sec
INFO (2)	148.4 Ops/sec
WARN (1)	1844.8 Ops/sec
WARN (2)	125.0 Ops/sec
ERROR (1)	1123.8 Ops/sec
ERROR (2)	148.7 Ops/sec
SILENT (1)	1943.0 Ops/sec
SILENT (2)	228.0 Ops/sec

VERBOSE (1)

const level = 'LH:*';
const rules = level
  .replace(/\s/g, '')
  .replace(/\*/g, '.+')
  .split(',')
  .reduce((rules, namespace) => {
    if (!/^-?LH:/.test(namespace)) return rules;
    let key = 'enabled';
    if ('-' === namespace[0]) {
      key = 'disabled';
      namespace = namespace.slice(1);
    }
    const rule = new RegExp(`^${namespace}$`);
    const ruleGroup = rules[key] ?? [];
    return { ...rules, [key]: [...ruleGroup, rule] };
  }, {});
for (const ns of namespaces) {
  const testRule = (rule) => rule.test(ns);
  const enabled_ = (rules.enabled?.some(testRule) ?? true) && !rules.disabled?.some(testRule);
}

VERBOSE (2)

const level = 'LH:*';
let enabled_ = false;
const rules = level
  .replace(/\s/g, '')
  .replace(/\*/g, '.+')
  .split(',')
  .reduce((rules, namespace) => {
    if (!/^-?LH:/.test(namespace)) return rules;
    let enabled = true;
    if ('-' === namespace[0]) {
      namespace = namespace.slice(1);
      enabled = false;
    }
    rules[namespace] = { pattern: new RegExp(`^${namespace}$`), enabled };
    return rules;
  }, {});
for (const ns of namespaces) {
  for (const key of Object.keys(rules).sort().reverse()) {
    if (rules[key].pattern.test(ns)) {
      enabled_ = rules[key].enabled;
      break;
    }
  }
}

INFO (1)

const level = 'LH:*, -LH:*:verbose';
const rules = level
  .replace(/\s/g, '')
  .replace(/\*/g, '.+')
  .split(',')
  .reduce((rules, namespace) => {
    if (!/^-?LH:/.test(namespace)) return rules;
    let key = 'enabled';
    if ('-' === namespace[0]) {
      key = 'disabled';
      namespace = namespace.slice(1);
    }
    const rule = new RegExp(`^${namespace}$`);
    const ruleGroup = rules[key] ?? [];
    return { ...rules, [key]: [...ruleGroup, rule] };
  }, {});
for (const ns of namespaces) {
  const testRule = (rule) => rule.test(ns);
  const enabled_ = (rules.enabled?.some(testRule) ?? true) && !rules.disabled?.some(testRule);
}

INFO (2)

const level = 'LH:*, -LH:*:verbose';
const rules = level
  .replace(/\s/g, '')
  .replace(/\*/g, '.+')
  .split(',')
  .reduce((rules, namespace) => {
    if (!/^-?LH:/.test(namespace)) return rules;
    let enabled = true;
    if ('-' === namespace[0]) {
      namespace = namespace.slice(1);
      enabled = false;
    }
    rules[namespace] = { pattern: new RegExp(`^${namespace}$`), enabled };
    return rules;
  }, {});
for (const ns of namespaces) {
  for (const key of Object.keys(rules).sort().reverse()) {
    if (rules[key].pattern.test(ns)) {
      enabled_ = rules[key].enabled;
      break;
    }
  }
}

WARN (1)

const level = 'LH:*, LH:*:warn, LH:*:error';
const rules = level
  .replace(/\s/g, '')
  .replace(/\*/g, '.+')
  .split(',')
  .reduce((rules, namespace) => {
    if (!/^-?LH:/.test(namespace)) return rules;
    let key = 'enabled';
    if ('-' === namespace[0]) {
      key = 'disabled';
      namespace = namespace.slice(1);
    }
    const rule = new RegExp(`^${namespace}$`);
    const ruleGroup = rules[key] ?? [];
    return { ...rules, [key]: [...ruleGroup, rule] };
  }, {});
for (const ns of namespaces) {
  const testRule = (rule) => rule.test(ns);
  const enabled_ = (rules.enabled?.some(testRule) ?? true) && !rules.disabled?.some(testRule);
}

WARN (2)

const level = 'LH:*, LH:*:warn, LH:*:error';
const rules = level
  .replace(/\s/g, '')
  .replace(/\*/g, '.+')
  .split(',')
  .reduce((rules, namespace) => {
    if (!/^-?LH:/.test(namespace)) return rules;
    let enabled = true;
    if ('-' === namespace[0]) {
      namespace = namespace.slice(1);
      enabled = false;
    }
    rules[namespace] = { pattern: new RegExp(`^${namespace}$`), enabled };
    return rules;
  }, {});
for (const ns of namespaces) {
  for (const key of Object.keys(rules).sort().reverse()) {
    if (rules[key].pattern.test(ns)) {
      enabled_ = rules[key].enabled;
      break;
    }
  }
}

ERROR (1)

const level = '-LH:*, LH:*:error';
const rules = level
  .replace(/\s/g, '')
  .replace(/\*/g, '.+')
  .split(',')
  .reduce((rules, namespace) => {
    if (!/^-?LH:/.test(namespace)) return rules;
    let key = 'enabled';
    if ('-' === namespace[0]) {
      key = 'disabled';
      namespace = namespace.slice(1);
    }
    const rule = new RegExp(`^${namespace}$`);
    const ruleGroup = rules[key] ?? [];
    return { ...rules, [key]: [...ruleGroup, rule] };
  }, {});
for (const ns of namespaces) {
  const testRule = (rule) => rule.test(ns);
  const enabled_ = (rules.enabled?.some(testRule) ?? true) && !rules.disabled?.some(testRule);
}

ERROR (2)

const level = '-LH:*, LH:*:error';
const rules = level
  .replace(/\s/g, '')
  .replace(/\*/g, '.+')
  .split(',')
  .reduce((rules, namespace) => {
    if (!/^-?LH:/.test(namespace)) return rules;
    let enabled = true;
    if ('-' === namespace[0]) {
      namespace = namespace.slice(1);
      enabled = false;
    }
    rules[namespace] = { pattern: new RegExp(`^${namespace}$`), enabled };
    return rules;
  }, {});
for (const ns of namespaces) {
  for (const key of Object.keys(rules).sort().reverse()) {
    if (rules[key].pattern.test(ns)) {
      enabled_ = rules[key].enabled;
      break;
    }
  }
}

SILENT (1)

const level = '-LH:*';
const rules = level
  .replace(/\s/g, '')
  .replace(/\*/g, '.+')
  .split(',')
  .reduce((rules, namespace) => {
    if (!/^-?LH:/.test(namespace)) return rules;
    let key = 'enabled';
    if ('-' === namespace[0]) {
      key = 'disabled';
      namespace = namespace.slice(1);
    }
    const rule = new RegExp(`^${namespace}$`);
    const ruleGroup = rules[key] ?? [];
    return { ...rules, [key]: [...ruleGroup, rule] };
  }, {});
for (const ns of namespaces) {
  const testRule = (rule) => rule.test(ns);
  const enabled_ = (rules.enabled?.some(testRule) ?? true) && !rules.disabled?.some(testRule);
}

SILENT (2)

const level = '-LH:*';
const rules = level
  .replace(/\s/g, '')
  .replace(/\*/g, '.+')
  .split(',')
  .reduce((rules, namespace) => {
    if (!/^-?LH:/.test(namespace)) return rules;
    let enabled = true;
    if ('-' === namespace[0]) {
      namespace = namespace.slice(1);
      enabled = false;
    }
    rules[namespace] = { pattern: new RegExp(`^${namespace}$`), enabled };
    return rules;
  }, {});
for (const ns of namespaces) {
  for (const key of Object.keys(rules).sort().reverse()) {
    if (rules[key].pattern.test(ns)) {
      enabled_ = rules[key].enabled;
      break;
    }
  }
}