function updateCommonMetrics() {
	this.logger.debug("Update common metric values...");
	const end = this.timer();

	// --- PROCESS METRICS ---

	const procMem = process.memoryUsage();

	this.set(METRIC.PROCESS_MEMORY_HEAP_SIZE_TOTAL, procMem.heapTotal);
	this.set(METRIC.PROCESS_MEMORY_HEAP_SIZE_USED, procMem.heapUsed);
	this.set(METRIC.PROCESS_MEMORY_RSS, procMem.rss);
	this.set(METRIC.PROCESS_MEMORY_EXTERNAL, procMem.external);

	if (v8 && v8.getHeapSpaceStatistics) {
		const stat = v8.getHeapSpaceStatistics();
		stat.forEach(item => {
			const space = item.space_name;
			this.set(METRIC.PROCESS_MEMORY_HEAP_SPACE_SIZE_TOTAL, item.space_size, { space });
			this.set(METRIC.PROCESS_MEMORY_HEAP_SPACE_SIZE_USED, item.space_used_size, { space });
			this.set(METRIC.PROCESS_MEMORY_HEAP_SPACE_SIZE_AVAILABLE, item.space_available_size, {
				space
			});
			this.set(METRIC.PROCESS_MEMORY_HEAP_SPACE_SIZE_PHYSICAL, item.physical_space_size, {
				space
			});
		});
	}

	if (v8 && v8.getHeapStatistics) {
		const stat = v8.getHeapStatistics();
		this.set(METRIC.PROCESS_MEMORY_HEAP_STAT_HEAP_SIZE_TOTAL, stat.total_heap_size);
		this.set(
			METRIC.PROCESS_MEMORY_HEAP_STAT_EXECUTABLE_SIZE_TOTAL,
			stat.total_heap_size_executable
		);
		this.set(METRIC.PROCESS_MEMORY_HEAP_STAT_PHYSICAL_SIZE_TOTAL, stat.total_physical_size);
		this.set(METRIC.PROCESS_MEMORY_HEAP_STAT_AVAILABLE_SIZE_TOTAL, stat.total_available_size);
		this.set(METRIC.PROCESS_MEMORY_HEAP_STAT_USED_HEAP_SIZE, stat.used_heap_size);
		this.set(METRIC.PROCESS_MEMORY_HEAP_STAT_HEAP_SIZE_LIMIT, stat.heap_size_limit);
		this.set(METRIC.PROCESS_MEMORY_HEAP_STAT_MALLOCATED_MEMORY, stat.malloced_memory);
		this.set(METRIC.PROCESS_MEMORY_HEAP_STAT_PEAK_MALLOCATED_MEMORY, stat.peak_malloced_memory);
		this.set(METRIC.PROCESS_MEMORY_HEAP_STAT_ZAP_GARBAGE, stat.does_zap_garbage);
	}

	this.set(METRIC.PROCESS_UPTIME, process.uptime());
	this.set(METRIC.PROCESS_INTERNAL_ACTIVE_HANDLES, process._getActiveHandles().length);
	this.set(METRIC.PROCESS_INTERNAL_ACTIVE_REQUESTS, process._getActiveRequests().length);

	// --- OS METRICS ---

	const freeMem = os.freemem();
	const totalMem = os.totalmem();
	const usedMem = totalMem - freeMem;
	this.set(METRIC.OS_MEMORY_FREE, freeMem);
	this.set(METRIC.OS_MEMORY_USED, usedMem);
	this.set(METRIC.OS_MEMORY_TOTAL, totalMem);
	this.set(METRIC.OS_UPTIME, os.uptime());
	this.set(METRIC.OS_TYPE, os.type());
	this.set(METRIC.OS_RELEASE, os.release());
	this.set(METRIC.OS_HOSTNAME, os.hostname());
	this.set(METRIC.OS_ARCH, os.arch());
	this.set(METRIC.OS_PLATFORM, os.platform());

	// --- NETWORK INTERFACES ---

	const getNetworkInterfaces = () => {
		const list = [];
		const ilist = [];
		const interfaces = os.networkInterfaces();
		for (let iface in interfaces) {
			for (let i in interfaces[iface]) {
				const f = interfaces[iface][i];
				if (f.internal) {
					ilist.push({ f, iface });
				} else {
					list.push({ f, iface });
				}
			}
		}
		return list.length > 0 ? list : ilist;
	};

	const interfaces = getNetworkInterfaces();
	for (let { f, iface } of interfaces) {
		this.set(METRIC.OS_NETWORK_ADDRESS, f.address, { interface: iface, family: f.family });
		this.set(METRIC.OS_NETWORK_MAC, f.mac, { interface: iface, family: f.family });
	}

	const d = new Date();
	this.set(METRIC.OS_DATETIME_UNIX, d.valueOf());
	this.set(METRIC.OS_DATETIME_ISO, d.toISOString());
	this.set(METRIC.OS_DATETIME_UTC, d.toUTCString());
	this.set(METRIC.OS_DATETIME_TZ_OFFSET, d.getTimezoneOffset());

	const load = os.loadavg();
	this.set(METRIC.OS_CPU_LOAD_1, load[0]);
	this.set(METRIC.OS_CPU_LOAD_5, load[1]);
	this.set(METRIC.OS_CPU_LOAD_15, load[2]);

	if (eventLoop && eventLoop.sense) {
		const stat = eventLoop.sense();
		this.set(METRIC.PROCESS_EVENTLOOP_LAG_MIN, stat.min);
		this.set(METRIC.PROCESS_EVENTLOOP_LAG_AVG, stat.num ? stat.sum / stat.num : 0);
		this.set(METRIC.PROCESS_EVENTLOOP_LAG_MAX, stat.max);
		this.set(METRIC.PROCESS_EVENTLOOP_LAG_COUNT, stat.num);
	}

	// this.increment(METRIC.MOLECULER_METRICS_COMMON_COLLECT_TOTAL);
	const duration = end();

	return this.broker.Promise.resolve()
		.then(() =>
			cpuUsage().then(res => {
				this.set(METRIC.OS_CPU_UTILIZATION, res.avg);

				try {
					const cpus = os.cpus();
					this.set(METRIC.OS_CPU_TOTAL, cpus.length);
					this.set(
						METRIC.OS_CPU_USER,
						cpus.reduce((a, b) => a + b.times.user, 0)
					);
					this.set(
						METRIC.OS_CPU_SYSTEM,
						cpus.reduce((a, b) => a + b.times.sys, 0)
					);

					cpus.forEach((cpu, index) => {
						this.set(METRIC.OS_CPU_INFO_MODEL, cpu.model, { index });
						this.set(METRIC.OS_CPU_INFO_SPEED, cpu.speed, { index });
						this.set(METRIC.OS_CPU_INFO_TIMES_USER, cpu.times.user, { index });
						this.set(METRIC.OS_CPU_INFO_TIMES_SYS, cpu.times.sys, { index });
					});
				} catch (err) {
					// silent
				}
			})
		)
		.catch(() => {
			// silent this.logger.warn("Unable to collect CPU usage metrics.", err);
		})
		.then(() => {
			this.logger.debug(`Collected common metric values in ${duration.toFixed(3)} msec.`);
		});
}
Update common metric values.

@returns {Promise}