Run results for: Rule Benchmark (2)

Run details:

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36

Browser: Chrome 111

Operating system: Windows

Device Platform: Desktop

Date tested: one year ago

Test name	Executions per second
VERBOSE (1)	1845.8 Ops/sec
VERBOSE (2)	431.9 Ops/sec
INFO (1)	865.1 Ops/sec
INFO (2)	149.3 Ops/sec
WARN (1)	831.9 Ops/sec
WARN (2)	126.6 Ops/sec
ERROR (1)	1250.8 Ops/sec
ERROR (2)	147.2 Ops/sec
SILENT (1)	2006.8 Ops/sec
SILENT (2)	244.9 Ops/sec

Script Preparation code:

var namespaces = [];
for (var i = 0; i < 10000; i++) {
  let predicate = Math.random();
  let level = '';
  if (predicate < 0.25) {
    level = ':error';
  } else if (predicate < 0.5) {
    level = ':warn';
  } else if (predicate < 0.75) {
    level = ':verbose';
  }
  namespaces.push(`LH:${Math.floor(Math.random() * 1000)}${level}`);
}

Tests:

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; } } }

Run results for: Rule Benchmark (2)

VERBOSE (1)

VERBOSE (2)

INFO (1)

INFO (2)

WARN (1)

WARN (2)

ERROR (1)

ERROR (2)

SILENT (1)

SILENT (2)