diff --git a/Cargo.lock b/Cargo.lock
index 999eb30ad8..605fce9c84 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -268,11 +268,11 @@ dependencies = [
 
 [[package]]
 name = "atomic-shim"
-version = "0.1.0"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d20fdac7156779a1a30d970e838195558b4810dd06aa69e7c7461bdc518edf9b"
+checksum = "67cd4b51d303cf3501c301e8125df442128d3c6d7c69f71b27833d253de47e77"
 dependencies = [
- "crossbeam",
+ "crossbeam-utils 0.8.8",
 ]
 
 [[package]]
@@ -534,15 +534,6 @@ version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
-[[package]]
-name = "bitmaps"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "031043d04099746d8db04daf1fa424b2bc8bd69d92b25962dcde24da39ab64a2"
-dependencies = [
- "typenum",
-]
-
 [[package]]
 name = "bitvec"
 version = "0.18.5"
@@ -1058,11 +1049,11 @@ dependencies = [
  "lightning-invoice",
  "lightning-net-tokio",
  "lightning-persister",
- "metrics",
  "mm2_core",
  "mm2_db",
  "mm2_err_handle",
  "mm2_io",
+ "mm2_metrics",
  "mm2_net",
  "mm2_number",
  "mm2_test_helpers",
@@ -1131,6 +1122,7 @@ dependencies = [
  "hex 0.4.2",
  "mm2_core",
  "mm2_err_handle",
+ "mm2_metrics",
  "mm2_number",
  "rpc",
  "rpc_task",
@@ -1149,7 +1141,6 @@ dependencies = [
  "arrayref",
  "async-trait",
  "backtrace",
- "base64 0.10.1",
  "bytes 1.1.0",
  "cc",
  "cfg-if 1.0.0",
@@ -1163,7 +1154,6 @@ dependencies = [
  "futures-cpupool",
  "getrandom 0.2.6",
  "gstuff",
- "hdrhistogram 7.1.0",
  "hex 0.4.2",
  "http 0.2.7",
  "http-body 0.1.0",
@@ -1176,10 +1166,6 @@ dependencies = [
  "lightning",
  "log 0.4.14",
  "log4rs",
- "metrics",
- "metrics-core",
- "metrics-runtime",
- "metrics-util",
  "parking_lot 0.12.0",
  "parking_lot_core 0.6.2",
  "rand 0.7.3",
@@ -1952,6 +1938,12 @@ dependencies = [
  "cfg-if 1.0.0",
 ]
 
+[[package]]
+name = "endian-type"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c34f04666d835ff5d62e058c3995147c06f42fe86ff053337632bca83e42702d"
+
 [[package]]
 name = "enum-as-inner"
 version = "0.4.0"
@@ -2691,27 +2683,6 @@ dependencies = [
  "hashbrown 0.9.1",
 ]
 
-[[package]]
-name = "hdrhistogram"
-version = "6.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08d331ebcdbca4acbefe5da8c3299b2e246f198a8294cc5163354e743398b89d"
-dependencies = [
- "byteorder 1.4.3",
- "num-traits",
-]
-
-[[package]]
-name = "hdrhistogram"
-version = "7.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3c22708574c44e924720c5b3a116326c688e6d532f438c77c007ec8768644f9"
-dependencies = [
- "byteorder 1.4.3",
- "crossbeam-channel 0.4.4",
- "num-traits",
-]
-
 [[package]]
 name = "heck"
 version = "0.4.0"
@@ -3014,20 +2985,6 @@ dependencies = [
  "winapi",
 ]
 
-[[package]]
-name = "im"
-version = "15.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0acd33ff0285af998aaf9b57342af478078f53492322fafc47450e09397e0e9"
-dependencies = [
- "bitmaps",
- "rand_core 0.6.3",
- "rand_xoshiro",
- "sized-chunks",
- "typenum",
- "version_check",
-]
-
 [[package]]
 name = "impl-codec"
 version = "0.6.0"
@@ -3074,9 +3031,9 @@ checksum = "5a9d968042a4902e08810946fc7cd5851eb75e80301342305af755ca06cb82ce"
 
 [[package]]
 name = "indexmap"
-version = "1.7.0"
+version = "1.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc633605454125dec4b66843673f01c7df2b89479b32e0ed634e43a91cff62a5"
+checksum = "e6012d540c5baa3589337a98ce73408de9b5a25ec9fc2c6fd6be8f0d39e0ca5a"
 dependencies = [
  "autocfg 1.0.0",
  "hashbrown 0.11.2",
@@ -3862,6 +3819,15 @@ dependencies = [
  "linked-hash-map",
 ]
 
+[[package]]
+name = "mach"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b823e83b2affd8f40a9ee8c29dbc56404c1e34cd2710921f2801e2cf29527afa"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "match_cfg"
 version = "0.1.0"
@@ -3937,56 +3903,62 @@ dependencies = [
 
 [[package]]
 name = "metrics"
-version = "0.12.1"
+version = "0.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51b70227ece8711a1aa2f99655efd795d0cff297a5b9fe39645a93aacf6ad39d"
+checksum = "142c53885123b68d94108295a09d4afe1a1388ed95b54d5dacd9a454753030f2"
 dependencies = [
- "metrics-core",
+ "ahash 0.7.6",
+ "metrics-macros",
 ]
 
 [[package]]
-name = "metrics-core"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c064b3a1ff41f4bf6c91185c8a0caeccf8a8a27e9d0f92cc54cf3dbec812f48"
-
-[[package]]
-name = "metrics-observer-prometheus"
-version = "0.1.4"
+name = "metrics-exporter-prometheus"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bfe24ad8285ef8b239232135a65f89cc5fa4690bbfaf8907f4bef38f8b08eba"
+checksum = "953cbbb6f9ba4b9304f4df79b98cdc9d14071ed93065a9fca11c00c5d9181b66"
 dependencies = [
- "hdrhistogram 6.3.4",
- "metrics-core",
+ "hyper",
+ "indexmap",
+ "ipnet",
+ "metrics",
  "metrics-util",
+ "parking_lot 0.11.1",
+ "quanta",
+ "thiserror",
+ "tokio",
+ "tracing",
 ]
 
 [[package]]
-name = "metrics-runtime"
-version = "0.13.1"
+name = "metrics-macros"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce0e4f69639ccc0c6b2f0612164f9817349eb25545ed1ffb5ef3e1e1c1d220b4"
+checksum = "49e30813093f757be5cf21e50389a24dc7dbb22c49f23b7e8f51d69b508a5ffa"
 dependencies = [
- "arc-swap",
- "atomic-shim",
- "crossbeam-utils 0.7.2",
- "im",
- "metrics",
- "metrics-core",
- "metrics-observer-prometheus",
- "metrics-util",
- "parking_lot 0.10.2",
- "quanta",
+ "proc-macro2 1.0.39",
+ "quote 1.0.18",
+ "syn 1.0.95",
 ]
 
 [[package]]
 name = "metrics-util"
-version = "0.3.1"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d11f8090a8886339f9468a04eeea0711e4cf27538b134014664308041307a1c5"
+checksum = "fd1f4b69bef1e2b392b2d4a12902f2af90bb438ba4a66aa222d1023fa6561b50"
 dependencies = [
- "crossbeam-epoch 0.8.2",
- "serde",
+ "aho-corasick",
+ "atomic-shim",
+ "crossbeam-epoch 0.9.5",
+ "crossbeam-utils 0.8.8",
+ "hashbrown 0.11.2",
+ "indexmap",
+ "metrics",
+ "num_cpus",
+ "ordered-float",
+ "parking_lot 0.11.1",
+ "quanta",
+ "radix_trie",
+ "sketches-ddsketch",
 ]
 
 [[package]]
@@ -4095,6 +4067,7 @@ dependencies = [
  "hex 0.4.2",
  "keys",
  "lazy_static",
+ "mm2_metrics",
  "mm2_rpc",
  "primitives",
  "rand 0.7.3",
@@ -4202,12 +4175,12 @@ dependencies = [
  "keys",
  "lazy_static",
  "libc",
- "metrics",
  "mm2-libp2p",
  "mm2_core",
  "mm2_db",
  "mm2_err_handle",
  "mm2_io",
+ "mm2_metrics",
  "mm2_net",
  "mm2_number",
  "mm2_rpc",
@@ -4248,6 +4221,27 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "mm2_metrics"
+version = "0.1.0"
+dependencies = [
+ "base64 0.10.1",
+ "common",
+ "derive_more",
+ "futures 0.3.15",
+ "hyper",
+ "hyper-rustls",
+ "itertools",
+ "metrics",
+ "metrics-exporter-prometheus",
+ "metrics-util",
+ "mm2_err_handle",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-timer",
+]
+
 [[package]]
 name = "mm2_net"
 version = "0.1.0"
@@ -4321,6 +4315,7 @@ dependencies = [
  "lazy_static",
  "mm2_core",
  "mm2_io",
+ "mm2_metrics",
  "mm2_net",
  "mm2_number",
  "rand 0.7.3",
@@ -4414,6 +4409,15 @@ dependencies = [
  "unsigned-varint 0.7.1",
 ]
 
+[[package]]
+name = "nibble_vec"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77a5d83df9f36fe23f0c3648c6bbb8b0298bb5f1939c8f2704431371f4b84d43"
+dependencies = [
+ "smallvec 1.6.1",
+]
+
 [[package]]
 name = "nix"
 version = "0.23.1"
@@ -4589,6 +4593,15 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"
 
+[[package]]
+name = "ordered-float"
+version = "2.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7940cf2ca942593318d07fcf2596cdca60a85c9e7fab408a5e21a4f9dcd40d87"
+dependencies = [
+ "num-traits",
+]
+
 [[package]]
 name = "ouroboros"
 version = "0.13.0"
@@ -4732,16 +4745,6 @@ dependencies = [
  "rustc_version 0.2.3",
 ]
 
-[[package]]
-name = "parking_lot"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3a704eb390aafdc107b0e392f56a82b668e3a71366993b5340f5833fd62505e"
-dependencies = [
- "lock_api 0.3.4",
- "parking_lot_core 0.7.2",
-]
-
 [[package]]
 name = "parking_lot"
 version = "0.11.1"
@@ -4760,7 +4763,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "87f5ec2493a61ac0506c0f4199f99070cbe83857b0337006a30f3e6719b8ef58"
 dependencies = [
  "lock_api 0.4.6",
- "parking_lot_core 0.9.1",
+ "parking_lot_core 0.9.3",
 ]
 
 [[package]]
@@ -4791,20 +4794,6 @@ dependencies = [
  "winapi",
 ]
 
-[[package]]
-name = "parking_lot_core"
-version = "0.7.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d58c7c768d4ba344e3e8d72518ac13e259d7c7ade24167003b8488e10b6740a3"
-dependencies = [
- "cfg-if 0.1.10",
- "cloudabi 0.0.3",
- "libc",
- "redox_syscall 0.1.56",
- "smallvec 1.6.1",
- "winapi",
-]
-
 [[package]]
 name = "parking_lot_core"
 version = "0.8.0"
@@ -4822,9 +4811,9 @@ dependencies = [
 
 [[package]]
 name = "parking_lot_core"
-version = "0.9.1"
+version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28141e0cc4143da2443301914478dc976a61ffdb3f043058310c70df2fed8954"
+checksum = "09a279cbf25cb0757810394fbc1e359949b59e348145c643a939a525692e6929"
 dependencies = [
  "cfg-if 1.0.0",
  "libc",
@@ -4871,9 +4860,9 @@ checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e"
 
 [[package]]
 name = "petgraph"
-version = "0.6.1"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51b305cc4569dd4e8765bab46261f67ef5d4d11a4b6e745100ee5dad8948b46c"
+checksum = "e6d5014253a1331579ce62aa67443b4a658c5e7dd03d4bc6d302b94474888143"
 dependencies = [
  "fixedbitset",
  "indexmap",
@@ -5187,11 +5176,17 @@ dependencies = [
 
 [[package]]
 name = "quanta"
-version = "0.3.1"
+version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4f7a1905379198075914bc93d32a5465c40474f90a078bb13439cb00c547bcc"
+checksum = "20afe714292d5e879d8b12740aa223c6a88f118af41870e8b6196e39a02238a8"
 dependencies = [
+ "crossbeam-utils 0.8.8",
  "libc",
+ "mach",
+ "once_cell",
+ "raw-cpuid",
+ "wasi 0.10.2+wasi-snapshot-preview1",
+ "web-sys",
  "winapi",
 ]
 
@@ -5266,6 +5261,16 @@ version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
 
+[[package]]
+name = "radix_trie"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c069c179fcdc6a2fe24d8d18305cf085fdbd4f922c041943e203685d6a1c58fd"
+dependencies = [
+ "endian-type",
+ "nibble_vec",
+]
+
 [[package]]
 name = "rand"
 version = "0.3.23"
@@ -5487,12 +5492,12 @@ dependencies = [
 ]
 
 [[package]]
-name = "rand_xoshiro"
-version = "0.6.0"
+name = "raw-cpuid"
+version = "10.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f97cdb2a36ed4183de61b2f824cc45c9f1037f28afe0a322e9fff4c108b5aaa"
+checksum = "738bc47119e3eeccc7e94c4a506901aea5e7b4944ecd0829cbebf4af04ceda12"
 dependencies = [
- "rand_core 0.6.3",
+ "bitflags",
 ]
 
 [[package]]
@@ -6332,14 +6337,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "833011ca526bd88f16778d32c699d325a9ad302fa06381cd66f7be63351d3f6d"
 
 [[package]]
-name = "sized-chunks"
-version = "0.6.5"
+name = "sketches-ddsketch"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16d69225bde7a69b235da73377861095455d298f2b970996eec25ddbb42b3d1e"
-dependencies = [
- "bitmaps",
- "typenum",
-]
+checksum = "04d2ecae5fcf33b122e2e6bd520a57ccf152d2dde3b38c71039df1a6867264ee"
 
 [[package]]
 name = "slab"
@@ -8605,9 +8606,9 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
 name = "windows-sys"
-version = "0.32.0"
+version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3df6e476185f92a12c072be4a189a0210dcdcf512a1891d6dff9edb874deadc6"
+checksum = "ea04155a16a59f9eab786fe12a4a450e75cdb175f9e0d80da1e17db09f55b8d2"
 dependencies = [
  "windows_aarch64_msvc",
  "windows_i686_gnu",
@@ -8618,33 +8619,33 @@ dependencies = [
 
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.32.0"
+version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8e92753b1c443191654ec532f14c199742964a061be25d77d7a96f09db20bf5"
+checksum = "9bb8c3fd39ade2d67e9874ac4f3db21f0d710bee00fe7cab16949ec184eeaa47"
 
 [[package]]
 name = "windows_i686_gnu"
-version = "0.32.0"
+version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a711c68811799e017b6038e0922cb27a5e2f43a2ddb609fe0b6f3eeda9de615"
+checksum = "180e6ccf01daf4c426b846dfc66db1fc518f074baa793aa7d9b9aaeffad6a3b6"
 
 [[package]]
 name = "windows_i686_msvc"
-version = "0.32.0"
+version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "146c11bb1a02615db74680b32a68e2d61f553cc24c4eb5b4ca10311740e44172"
+checksum = "e2e7917148b2812d1eeafaeb22a97e4813dfa60a3f8f78ebe204bcc88f12f024"
 
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.32.0"
+version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c912b12f7454c6620635bbff3450962753834be2a594819bd5e945af18ec64bc"
+checksum = "4dcd171b8776c41b97521e5da127a2d86ad280114807d0b2ab1e462bc764d9e1"
 
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.32.0"
+version = "0.36.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "504a2476202769977a040c6364301a3f65d0cc9e3fb08600b2bda150a0488316"
+checksum = "c811ca4a8c853ef420abd8592ba53ddbbac90410fab6903b3e79972a631f7680"
 
 [[package]]
 name = "winreg"
diff --git a/Cargo.toml b/Cargo.toml
index e224d8eafb..5407e4c746 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -25,6 +25,7 @@ members = [
     "mm2src/mm2_err_handle",
     "mm2src/mm2_test_helpers",
     "mm2src/mm2_libp2p",
+    "mm2src/mm2_metrics",
     "mm2src/mm2_main",
     "mm2src/mm2_net",
     "mm2src/mm2_number",
diff --git a/deny.toml b/deny.toml
index 2c6b571716..cf6377f2c7 100644
--- a/deny.toml
+++ b/deny.toml
@@ -48,11 +48,9 @@ notice = "warn"
 # A list of advisory IDs to ignore. Note that ignored advisories will still
 # output a note when they are encountered.
 
-# RUSTSEC-2021-0113 is related to metrics-util crate that is not actively used for now despite being still present in deps tree
 # RUSTSEC-2020-0071 is related to time crate, which is used only by chrono in our deps tree, remove when https://github.com/chronotope/chrono/issues/700 is resolved
 # RUSTSEC-2022-0040 is related to owning-ref, which seems unmaintained. We need to find a way to get rid of it. https://github.com/KomodoPlatform/atomicDEX-API/issues/1429
 ignore = [
-    "RUSTSEC-2021-0113",
     "RUSTSEC-2020-0071",
     "RUSTSEC-2022-0040",
     #"RUSTSEC-0000-0000",
diff --git a/mm2src/coins/Cargo.toml b/mm2src/coins/Cargo.toml
index 617df41d6f..9a7886301b 100644
--- a/mm2src/coins/Cargo.toml
+++ b/mm2src/coins/Cargo.toml
@@ -51,10 +51,10 @@ lazy_static = "1.4"
 libc = "0.2"
 lightning = { git = "https://github.com/shamardy/rust-lightning", branch = "0.0.106" }
 lightning-invoice = { git = "https://github.com/shamardy/rust-lightning", branch = "0.0.106" }
-metrics = "0.12"
 mm2_core = { path = "../mm2_core" }
 mm2_err_handle = { path = "../mm2_err_handle" }
 mm2_io = { path = "../mm2_io" }
+mm2_metrics = { path = "../mm2_metrics" }
 mm2_net = { path = "../mm2_net" }
 mm2_number = { path = "../mm2_number" }
 mocktopus = "0.7.0"
diff --git a/mm2src/coins/lp_coins.rs b/mm2src/coins/lp_coins.rs
index 183ba32579..6fb9553a27 100644
--- a/mm2src/coins/lp_coins.rs
+++ b/mm2src/coins/lp_coins.rs
@@ -28,13 +28,13 @@
 #[macro_use] extern crate common;
 #[macro_use] extern crate gstuff;
 #[macro_use] extern crate lazy_static;
+#[macro_use] extern crate mm2_metrics;
 #[macro_use] extern crate serde_derive;
 #[macro_use] extern crate serde_json;
 #[macro_use] extern crate ser_error_derive;
 
 use async_trait::async_trait;
 use base58::FromBase58Error;
-use common::mm_metrics::MetricsWeak;
 use common::{calc_total_pages, now_ms, ten, HttpStatusCode};
 use crypto::{Bip32Error, CryptoCtx, DerivationPath};
 use derive_more::Display;
@@ -46,8 +46,9 @@ use http::{Response, StatusCode};
 use keys::{AddressFormat as UtxoAddressFormat, KeyPair, NetworkPrefix as CashAddrPrefix};
 use mm2_core::mm_ctx::{from_ctx, MmArc};
 use mm2_err_handle::prelude::*;
-use mm2_number::bigdecimal::{BigDecimal, ParseBigDecimalError, Zero};
-use mm2_number::MmNumber;
+use mm2_metrics::MetricsWeak;
+use mm2_number::{bigdecimal::{BigDecimal, ParseBigDecimalError, Zero},
+                 MmNumber};
 use rpc::v1::types::{Bytes as BytesJson, H256 as H256Json};
 use serde::{Deserialize, Deserializer, Serialize};
 use serde_json::{self as json, Value as Json};
@@ -2179,16 +2180,16 @@ impl RpcTransportEventHandler for CoinTransportMetrics {
 
     fn on_outgoing_request(&self, data: &[u8]) {
         mm_counter!(self.metrics, "rpc_client.traffic.out", data.len() as u64,
-            "coin" => self.ticker.clone(), "client" => self.client.clone());
+            "coin" => self.ticker.to_owned(), "client" => self.client.to_owned());
         mm_counter!(self.metrics, "rpc_client.request.count", 1,
-            "coin" => self.ticker.clone(), "client" => self.client.clone());
+            "coin" => self.ticker.to_owned(), "client" => self.client.to_owned());
     }
 
     fn on_incoming_response(&self, data: &[u8]) {
         mm_counter!(self.metrics, "rpc_client.traffic.in", data.len() as u64,
-            "coin" => self.ticker.clone(), "client" => self.client.clone());
+            "coin" => self.ticker.to_owned(), "client" => self.client.to_owned());
         mm_counter!(self.metrics, "rpc_client.response.count", 1,
-            "coin" => self.ticker.clone(), "client" => self.client.clone());
+            "coin" => self.ticker.to_owned(), "client" => self.client.to_owned());
     }
 
     fn on_connected(&self, _address: String) -> Result<(), String> {
diff --git a/mm2src/coins/qrc20/history.rs b/mm2src/coins/qrc20/history.rs
index 967ba82ba4..0b160c1994 100644
--- a/mm2src/coins/qrc20/history.rs
+++ b/mm2src/coins/qrc20/history.rs
@@ -3,8 +3,8 @@ use crate::utxo::{RequestTxHistoryResult, UtxoFeeDetails};
 use crate::{CoinsContext, TxFeeDetails, TxHistoryResult};
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 use common::jsonrpc_client::JsonRpcErrorType;
-use common::mm_metrics::MetricsArc;
 use itertools::Itertools;
+use mm2_metrics::MetricsArc;
 use script_pubkey::{extract_contract_call_from_script, extract_gas_from_script, ExtractGasEnum};
 use std::collections::HashMap;
 use std::io::Cursor;
@@ -813,7 +813,7 @@ fn is_transfer_event_log(log: &LogEntry) -> bool {
 mod tests {
     use super::*;
     use common::block_on;
-    use common::mm_metrics::{MetricType, MetricsJson, MetricsOps};
+    use mm2_metrics::{MetricType, MetricsJson, MetricsOps};
     use mm2_test_helpers::for_tests::find_metrics_in_json;
     use qrc20_tests::qrc20_coin_for_test;
 
@@ -840,7 +840,7 @@ mod tests {
             72, 172, 110, 180, 13, 123, 179, 10, 49,
         ];
         let (ctx, coin) = qrc20_coin_for_test(&priv_key, None);
-        ctx.metrics.init().unwrap();
+        ctx.metrics.init();
 
         let tx_hash: H256Json = hex::decode("85ede12ccc12fb1709c4d9e403e96c0c394b0916f2f6098d41d8dfa00013fcdb")
             .unwrap()
@@ -872,7 +872,7 @@ mod tests {
             72, 172, 110, 180, 13, 123, 179, 10, 49,
         ];
         let (ctx, coin) = qrc20_coin_for_test(&priv_key, None);
-        ctx.metrics.init().unwrap();
+        ctx.metrics.init();
 
         let tx_hash: H256Json = hex::decode("85ede12ccc12fb1709c4d9e403e96c0c394b0916f2f6098d41d8dfa00013fcdb")
             .unwrap()
@@ -914,7 +914,7 @@ mod tests {
             72, 172, 110, 180, 13, 123, 179, 10, 49,
         ];
         let (ctx, coin) = qrc20_coin_for_test(&priv_key, None);
-        ctx.metrics.init().unwrap();
+        ctx.metrics.init();
 
         let tx_hash: H256Json = hex::decode("85ede12ccc12fb1709c4d9e403e96c0c394b0916f2f6098d41d8dfa00013fcdb")
             .unwrap()
@@ -1008,7 +1008,7 @@ mod tests {
         let (ctx, coin) = qrc20_coin_for_test(&priv_key, None);
 
         let metrics = MetricsArc::new();
-        metrics.init().unwrap();
+        metrics.init();
 
         let tx_hash_invalid: H256Json = hex::decode("0000000000000000000000000000000000000000000000000000000000000000")
             .unwrap()
diff --git a/mm2src/coins/utxo.rs b/mm2src/coins/utxo.rs
index 45815465b0..526b1acb8f 100644
--- a/mm2src/coins/utxo.rs
+++ b/mm2src/coins/utxo.rs
@@ -46,7 +46,6 @@ use chain::{OutPoint, TransactionOutput, TxHashAlgo};
 #[cfg(not(target_arch = "wasm32"))]
 use common::first_char_to_upper;
 use common::jsonrpc_client::JsonRpcError;
-use common::mm_metrics::MetricsArc;
 use common::now_ms;
 use crypto::trezor::utxo::TrezorUtxoCoin;
 use crypto::{Bip32DerPathOps, Bip32Error, Bip44Chain, Bip44DerPathError, Bip44PathToAccount, Bip44PathToCoin,
@@ -63,6 +62,7 @@ pub use keys::{Address, AddressFormat as UtxoAddressFormat, AddressHashEnum, Key
 use lightning_invoice::Currency as LightningCurrency;
 use mm2_core::mm_ctx::MmArc;
 use mm2_err_handle::prelude::*;
+use mm2_metrics::MetricsArc;
 use mm2_number::BigDecimal;
 #[cfg(test)] use mocktopus::macros::*;
 use num_traits::ToPrimitive;
diff --git a/mm2src/coins/utxo/bch.rs b/mm2src/coins/utxo/bch.rs
index 1cbaea6a5e..567e1b836a 100644
--- a/mm2src/coins/utxo/bch.rs
+++ b/mm2src/coins/utxo/bch.rs
@@ -11,13 +11,13 @@ use crate::{BlockHeightAndTime, CanRefundHtlc, CoinBalance, CoinProtocol, Negoti
             SwapOps, TradePreimageValue, TransactionFut, TransactionType, TxFeeDetails, UnexpectedDerivationMethod,
             ValidateAddressResult, ValidatePaymentInput, VerificationResult, WithdrawFut};
 use common::log::warn;
-use common::mm_metrics::MetricsArc;
 use derive_more::Display;
 use futures::{FutureExt, TryFutureExt};
 use itertools::Either as EitherIter;
 use keys::hash::H256;
 use keys::CashAddress;
 pub use keys::NetworkPrefix as CashAddrPrefix;
+use mm2_metrics::MetricsArc;
 use mm2_number::MmNumber;
 use serde_json::{self as json, Value as Json};
 use serialization::{deserialize, CoinVariant};
diff --git a/mm2src/coins/utxo/bch_and_slp_tx_history.rs b/mm2src/coins/utxo/bch_and_slp_tx_history.rs
index 5da1212e9d..65b14e1a69 100644
--- a/mm2src/coins/utxo/bch_and_slp_tx_history.rs
+++ b/mm2src/coins/utxo/bch_and_slp_tx_history.rs
@@ -9,9 +9,9 @@ use crate::{BlockHeightAndTime, HistorySyncState, MarketCoinOps};
 use async_trait::async_trait;
 use common::executor::Timer;
 use common::log::{error, info};
-use common::mm_metrics::MetricsArc;
 use common::state_machine::prelude::*;
 use futures::compat::Future01CompatExt;
+use mm2_metrics::MetricsArc;
 use mm2_number::BigDecimal;
 use rpc::v1::types::H256 as H256Json;
 use std::collections::HashMap;
diff --git a/mm2src/coins/utxo/qtum.rs b/mm2src/coins/utxo/qtum.rs
index 70adae0cc2..dd28557da1 100644
--- a/mm2src/coins/utxo/qtum.rs
+++ b/mm2src/coins/utxo/qtum.rs
@@ -19,12 +19,12 @@ use crate::{eth, CanRefundHtlc, CoinBalance, CoinWithDerivationMethod, Delegatio
             GetWithdrawSenderAddress, NegotiateSwapContractAddrErr, PrivKeyBuildPolicy, SearchForSwapTxSpendInput,
             SignatureResult, StakingInfosFut, SwapOps, TradePreimageValue, TransactionFut, UnexpectedDerivationMethod,
             ValidateAddressResult, ValidatePaymentInput, VerificationResult, WithdrawFut, WithdrawSenderAddress};
-use common::mm_metrics::MetricsArc;
 use crypto::trezor::utxo::TrezorUtxoCoin;
 use crypto::Bip44Chain;
 use ethereum_types::H160;
 use futures::{FutureExt, TryFutureExt};
 use keys::AddressHashEnum;
+use mm2_metrics::MetricsArc;
 use mm2_number::MmNumber;
 use serde::Serialize;
 use serialization::CoinVariant;
diff --git a/mm2src/coins/utxo/utxo_common.rs b/mm2src/coins/utxo/utxo_common.rs
index 547086f00f..f99cb247a4 100644
--- a/mm2src/coins/utxo/utxo_common.rs
+++ b/mm2src/coins/utxo/utxo_common.rs
@@ -22,7 +22,6 @@ use chain::{OutPoint, TransactionOutput};
 use common::executor::Timer;
 use common::jsonrpc_client::JsonRpcErrorType;
 use common::log::{debug, error, info, warn};
-use common::mm_metrics::MetricsArc;
 use common::{now_ms, one_hundred, ten_f64};
 use crypto::{Bip32DerPathOps, Bip44Chain, Bip44DerPathError, Bip44DerivationPath, RpcDerivationPath};
 use futures::compat::Future01CompatExt;
diff --git a/mm2src/coins/utxo/utxo_standard.rs b/mm2src/coins/utxo/utxo_standard.rs
index b48f9bfe59..d03123fdc3 100644
--- a/mm2src/coins/utxo/utxo_standard.rs
+++ b/mm2src/coins/utxo/utxo_standard.rs
@@ -17,10 +17,10 @@ use crate::{CanRefundHtlc, CoinBalance, CoinWithDerivationMethod, GetWithdrawSen
             NegotiateSwapContractAddrErr, PrivKeyBuildPolicy, SearchForSwapTxSpendInput, SignatureResult, SwapOps,
             TradePreimageValue, TransactionFut, ValidateAddressResult, ValidatePaymentInput, VerificationResult,
             WithdrawFut, WithdrawSenderAddress};
-use common::mm_metrics::MetricsArc;
 use crypto::trezor::utxo::TrezorUtxoCoin;
 use crypto::Bip44Chain;
 use futures::{FutureExt, TryFutureExt};
+use mm2_metrics::MetricsArc;
 use mm2_number::MmNumber;
 use serialization::coin_variant_by_ticker;
 use utxo_signer::UtxoSignerOps;
diff --git a/mm2src/coins_activation/Cargo.toml b/mm2src/coins_activation/Cargo.toml
index 89f4ac538d..234ff102ef 100644
--- a/mm2src/coins_activation/Cargo.toml
+++ b/mm2src/coins_activation/Cargo.toml
@@ -12,6 +12,7 @@ common = { path = "../common" }
 ethereum-types = { version = "0.4", default-features = false, features = ["std", "serialize"] }
 mm2_core = { path = "../mm2_core" }
 mm2_err_handle = { path = "../mm2_err_handle" }
+mm2_metrics = { path = "../mm2_metrics" }
 mm2_number = { path = "../mm2_number" }
 crypto = { path = "../crypto" }
 derive_more = "0.99"
diff --git a/mm2src/coins_activation/src/bch_with_tokens_activation.rs b/mm2src/coins_activation/src/bch_with_tokens_activation.rs
index e0f3102b47..0ce4580e12 100644
--- a/mm2src/coins_activation/src/bch_with_tokens_activation.rs
+++ b/mm2src/coins_activation/src/bch_with_tokens_activation.rs
@@ -11,11 +11,11 @@ use coins::utxo::UtxoCommonOps;
 use coins::{CoinBalance, CoinProtocol, MarketCoinOps, MmCoin, PrivKeyNotAllowed, UnexpectedDerivationMethod};
 use common::executor::spawn;
 use common::log::info;
-use common::mm_metrics::MetricsArc;
 use common::Future01CompatExt;
 use futures::future::{abortable, AbortHandle};
 use mm2_core::mm_ctx::MmArc;
 use mm2_err_handle::prelude::*;
+use mm2_metrics::MetricsArc;
 use mm2_number::BigDecimal;
 use serde_derive::{Deserialize, Serialize};
 use serde_json::Value as Json;
diff --git a/mm2src/coins_activation/src/eth_with_token_activation.rs b/mm2src/coins_activation/src/eth_with_token_activation.rs
index 8e75488d53..33bf0b24c4 100644
--- a/mm2src/coins_activation/src/eth_with_token_activation.rs
+++ b/mm2src/coins_activation/src/eth_with_token_activation.rs
@@ -9,10 +9,11 @@ use coins::{eth::{v2_activation::{eth_coin_from_conf_and_request_v2, Erc20Protoc
                   Erc20TokenInfo, EthCoin, EthCoinType},
             my_tx_history_v2::TxHistoryStorage,
             CoinBalance, CoinProtocol, MarketCoinOps, MmCoin};
-use common::{mm_metrics::MetricsArc, Future01CompatExt};
+use common::Future01CompatExt;
 use futures::future::AbortHandle;
 use mm2_core::mm_ctx::MmArc;
 use mm2_err_handle::prelude::*;
+use mm2_metrics::MetricsArc;
 use mm2_number::BigDecimal;
 use serde::{Deserialize, Serialize};
 use serde_json::Value as Json;
diff --git a/mm2src/coins_activation/src/platform_coin_with_tokens.rs b/mm2src/coins_activation/src/platform_coin_with_tokens.rs
index ecd1dac377..61f58ed7cb 100644
--- a/mm2src/coins_activation/src/platform_coin_with_tokens.rs
+++ b/mm2src/coins_activation/src/platform_coin_with_tokens.rs
@@ -3,12 +3,12 @@ use async_trait::async_trait;
 use coins::my_tx_history_v2::TxHistoryStorage;
 use coins::tx_history_storage::{CreateTxHistoryStorageError, TxHistoryStorageBuilder};
 use coins::{lp_coinfind, CoinProtocol, CoinsContext, MmCoinEnum};
-use common::mm_metrics::MetricsArc;
 use common::{log, HttpStatusCode, StatusCode};
 use derive_more::Display;
 use futures::future::AbortHandle;
 use mm2_core::mm_ctx::MmArc;
 use mm2_err_handle::prelude::*;
+use mm2_metrics::MetricsArc;
 use mm2_number::BigDecimal;
 use ser_error_derive::SerializeErrorType;
 use serde_derive::{Deserialize, Serialize};
diff --git a/mm2src/coins_activation/src/solana_with_tokens_activation.rs b/mm2src/coins_activation/src/solana_with_tokens_activation.rs
index 71fdcf4027..851d5bff5d 100644
--- a/mm2src/coins_activation/src/solana_with_tokens_activation.rs
+++ b/mm2src/coins_activation/src/solana_with_tokens_activation.rs
@@ -10,11 +10,11 @@ use coins::my_tx_history_v2::TxHistoryStorage;
 use coins::solana::spl::{SplProtocolConf, SplTokenCreationError};
 use coins::{solana_coin_from_conf_and_params, BalanceError, CoinBalance, CoinProtocol, MarketCoinOps,
             SolanaActivationParams, SolanaCoin, SplToken};
-use common::mm_metrics::MetricsArc;
 use common::Future01CompatExt;
 use futures::future::AbortHandle;
 use mm2_core::mm_ctx::MmArc;
 use mm2_err_handle::prelude::*;
+use mm2_metrics::MetricsArc;
 use mm2_number::BigDecimal;
 use serde_derive::{Deserialize, Serialize};
 use serde_json::Value as Json;
diff --git a/mm2src/common/Cargo.toml b/mm2src/common/Cargo.toml
index ddb1e0015c..0ed80ea559 100644
--- a/mm2src/common/Cargo.toml
+++ b/mm2src/common/Cargo.toml
@@ -16,7 +16,6 @@ track-ctx-pointer = ["shared_ref_counter/enable", "shared_ref_counter/log"]
 arrayref = "0.3"
 async-trait = "0.1"
 backtrace = "0.3"
-base64 = "0.10.0"
 bytes = "1.1"
 cfg-if = "1.0"
 crossbeam = "0.7"
@@ -60,17 +59,12 @@ anyhow = "1.0"
 chrono = "0.4"
 crossterm = "0.20"
 gstuff = { version = "0.7", features = ["crossterm", "nightly"] }
-hdrhistogram = { version = "7.0", default-features = false, features = ["sync"] }
 hyper = { version = "0.14.11", features = ["client", "http2", "server", "tcp"] }
 # using webpki-tokio to avoid rejecting valid certificates
 # got "invalid certificate: UnknownIssuer" for https://ropsten.infura.io on iOS using default-features
 hyper-rustls = { version = "0.23", default-features = false, features = ["http1", "http2", "webpki-tokio"] }
 libc = { version = "0.2" }
 log4rs = { version = "1.0", default-features = false, features = ["console_appender", "pattern_encoder"] }
-metrics = { version = "0.12" }
-metrics-runtime = { version = "0.13", default-features = false, features = ["metrics-observer-prometheus"] }
-metrics-core = { version = "0.5" }
-metrics-util = { version = "0.3" }
 tokio = { version = "1.7", features = ["io-util", "rt-multi-thread", "net"] }
 
 [target.'cfg(windows)'.dependencies]
diff --git a/mm2src/common/common.rs b/mm2src/common/common.rs
index f07150ce6a..dee3b1de5a 100644
--- a/mm2src/common/common.rs
+++ b/mm2src/common/common.rs
@@ -96,8 +96,6 @@ macro_rules! drop_mutability {
 pub mod jsonrpc_client;
 #[macro_use]
 pub mod log;
-#[macro_use]
-pub mod mm_metrics;
 
 pub mod crash_reports;
 pub mod custom_futures;
diff --git a/mm2src/common/mm_metrics/mod.rs b/mm2src/common/mm_metrics/mod.rs
deleted file mode 100644
index 6c84d4de48..0000000000
--- a/mm2src/common/mm_metrics/mod.rs
+++ /dev/null
@@ -1,92 +0,0 @@
-use crate::log::LogWeak;
-use serde_json::{Value as Json, Value};
-use std::collections::HashMap;
-use std::sync::{Arc, Weak};
-
-#[cfg(not(target_arch = "wasm32"))] mod native;
-#[cfg(not(target_arch = "wasm32"))]
-pub use native::{prometheus, Clock, Metrics, TrySink};
-
-#[cfg(target_arch = "wasm32")] mod wasm;
-#[cfg(target_arch = "wasm32")] pub use wasm::{Clock, Metrics};
-
-pub trait MetricsOps {
-    /// If the instance was not initialized yet, create the `receiver` else return an error.
-    fn init(&self) -> Result<(), String>;
-
-    /// Create new Metrics instance and spawn the metrics recording into the log, else return an error.
-    fn init_with_dashboard(&self, log_state: LogWeak, record_interval: f64) -> Result<(), String>;
-
-    /// Handle for sending metric samples.
-    fn clock(&self) -> Result<Clock, String>;
-
-    /// Collect the metrics as Json.
-    fn collect_json(&self) -> Result<Json, String>;
-}
-
-pub trait ClockOps {
-    fn now(&self) -> u64;
-}
-
-#[derive(Clone, Default)]
-pub struct MetricsArc(pub Arc<Metrics>);
-
-impl MetricsOps for MetricsArc {
-    fn init(&self) -> Result<(), String> { self.0.init() }
-
-    fn init_with_dashboard(&self, log_state: LogWeak, record_interval: f64) -> Result<(), String> {
-        self.0.init_with_dashboard(log_state, record_interval)
-    }
-
-    fn clock(&self) -> Result<Clock, String> { self.0.clock() }
-
-    fn collect_json(&self) -> Result<Value, String> { self.0.collect_json() }
-}
-
-impl MetricsArc {
-    /// Create new `Metrics` instance
-    pub fn new() -> MetricsArc { MetricsArc(Arc::new(Default::default())) }
-
-    /// Try to obtain the `Metrics` from the weak pointer.
-    pub fn from_weak(weak: &MetricsWeak) -> Option<MetricsArc> { weak.0.upgrade().map(MetricsArc) }
-
-    /// Create a weak pointer from `MetricsWeak`.
-    pub fn weak(&self) -> MetricsWeak { MetricsWeak(Arc::downgrade(&self.0)) }
-}
-
-#[derive(Clone, Default)]
-pub struct MetricsWeak(pub Weak<Metrics>);
-
-impl MetricsWeak {
-    /// Create a default MmWeak without allocating any memory.
-    pub fn new() -> MetricsWeak { MetricsWeak::default() }
-
-    pub fn dropped(&self) -> bool { self.0.strong_count() == 0 }
-}
-
-#[derive(Serialize, Debug, Default, Deserialize)]
-pub struct MetricsJson {
-    pub metrics: Vec<MetricType>,
-}
-
-#[derive(Eq, Debug, Deserialize, PartialEq, Serialize)]
-#[serde(rename_all = "lowercase")]
-#[serde(tag = "type")]
-pub enum MetricType {
-    Counter {
-        key: String,
-        labels: HashMap<String, String>,
-        value: u64,
-    },
-    Gauge {
-        key: String,
-        labels: HashMap<String, String>,
-        value: i64,
-    },
-    Histogram {
-        key: String,
-        labels: HashMap<String, String>,
-        #[serde(flatten)]
-        quantiles: HashMap<String, u64>,
-    },
-}
diff --git a/mm2src/common/mm_metrics/native.rs b/mm2src/common/mm_metrics/native.rs
deleted file mode 100644
index fafa3beab0..0000000000
--- a/mm2src/common/mm_metrics/native.rs
+++ /dev/null
@@ -1,756 +0,0 @@
-use super::*;
-use crate::executor::{spawn, Timer};
-use crate::log::error;
-use gstuff::Constructible;
-use hdrhistogram::Histogram;
-use itertools::Itertools;
-use metrics_core::{Builder, Drain, Key, Label, Observe, Observer, ScopedString};
-use metrics_runtime::{observers::PrometheusBuilder, Receiver};
-use metrics_util::{parse_quantiles, Quantile};
-use serde_json as json;
-use std::collections::HashMap;
-use std::fmt;
-use std::slice::Iter;
-
-use crate::log::{LogArc, Tag};
-pub use metrics_runtime::Sink;
-
-/// Increment counter if an MmArc is not dropped yet and metrics system is initialized already.
-#[macro_export]
-macro_rules! mm_counter {
-    ($metrics:expr, $name:expr, $value:expr) => {{
-        if let Some(mut sink) = $crate::mm_metrics::TrySink::try_sink(&$metrics) {
-            sink.increment_counter($name, $value);
-        }
-    }};
-    ($metrics:expr, $name:expr, $value:expr, $($label_key:expr => $label_val:expr),+) => {{
-        use metrics::labels;
-        if let Some(mut sink) = $crate::mm_metrics::TrySink::try_sink(&$metrics) {
-            let labels = labels!( $($label_key => $label_val),+ );
-            sink.increment_counter_with_labels($name, $value, labels);
-        }
-    }};
-}
-
-/// Update gauge if an MmArc is not dropped yet and metrics system is initialized already.
-#[macro_export]
-macro_rules! mm_gauge {
-    ($metrics:expr, $name:expr, $value:expr) => {{
-        if let Some(mut sink) = $crate::mm_metrics::TrySink::try_sink(&$metrics) {
-            sink.update_gauge($name, $value);
-        }
-    }};
-
-    ($metrics:expr, $name:expr, $value:expr, $($label_key:expr => $label_val:expr),+) => {{
-        use metrics::labels;
-        if let Some(mut sink) = $crate::mm_metrics::TrySink::try_sink(&$metrics) {
-            let labels = labels!( $($label_key => $label_val),+ );
-            sink.update_gauge_with_labels($name, $value, labels);
-        }
-    }};
-}
-
-/// Pass new timing value if an MmArc is not dropped yet and metrics system is initialized already.
-#[macro_export]
-macro_rules! mm_timing {
-    ($metrics:expr, $name:expr, $start:expr, $end:expr) => {{
-        if let Some(mut sink) = $crate::mm_metrics::TrySink::try_sink(&$metrics) {
-            sink.record_timing($name, $start, $end);
-        }
-    }};
-
-    ($metrics:expr, $name:expr, $start:expr, $end:expr, $($label_key:expr => $label_val:expr),+) => {{
-        use metrics::labels;
-        if let Some(mut sink) = $crate::mm_metrics::TrySink::try_sink(&$metrics) {
-            let labels = labels!( $($label_key => $label_val),+ );
-            sink.record_timing_with_labels($name, $start, $end, labels);
-        }
-    }};
-}
-
-/// Default quantiles are "min" and "max"
-const QUANTILES: &[f64] = &[0.0, 1.0];
-
-pub trait TrySink {
-    fn try_sink(&self) -> Option<Sink>;
-}
-
-impl TrySink for MetricsArc {
-    fn try_sink(&self) -> Option<Sink> { self.0.sink().ok() }
-}
-
-impl TrySink for MetricsWeak {
-    fn try_sink(&self) -> Option<Sink> {
-        let metrics = MetricsArc::from_weak(self)?;
-        metrics.0.sink().ok()
-    }
-}
-
-pub struct Clock {
-    sink: Sink,
-}
-
-impl From<Sink> for Clock {
-    fn from(sink: Sink) -> Self { Clock { sink } }
-}
-
-impl ClockOps for Clock {
-    fn now(&self) -> u64 { self.sink.now() }
-}
-
-#[derive(Default)]
-pub struct Metrics {
-    /// `Receiver` receives and collect all the metrics sent through the `sink`.
-    /// The `receiver` can be initialized only once time.
-    receiver: Constructible<Receiver>,
-}
-
-impl MetricsOps for Metrics {
-    fn init(&self) -> Result<(), String> {
-        if self.receiver.is_some() {
-            return ERR!("metrics system is initialized already");
-        }
-
-        let receiver = try_s!(Receiver::builder().build());
-        let _ = try_s!(self.receiver.pin(receiver));
-
-        Ok(())
-    }
-
-    fn init_with_dashboard(&self, log_state: LogWeak, record_interval: f64) -> Result<(), String> {
-        self.init()?;
-
-        let controller = self.receiver.as_option().unwrap().controller();
-
-        let observer = TagObserver::new(QUANTILES);
-        let exporter = TagExporter {
-            log_state,
-            controller,
-            observer,
-        };
-
-        spawn(exporter.run(record_interval));
-
-        Ok(())
-    }
-
-    fn clock(&self) -> Result<Clock, String> { self.sink().map_err(|e| ERRL!("{}", e)).map(Clock::from) }
-
-    fn collect_json(&self) -> Result<Json, String> {
-        let receiver = try_s!(self.try_receiver());
-        let controller = receiver.controller();
-
-        let mut observer = JsonObserver::new(QUANTILES);
-
-        controller.observe(&mut observer);
-
-        observer.into_json()
-    }
-}
-
-impl Metrics {
-    /// Try get receiver.
-    fn try_receiver(&self) -> Result<&Receiver, String> {
-        self.receiver.ok_or("metrics system is not initialized yet".into())
-    }
-
-    fn sink(&self) -> Result<Sink, String> { Ok(try_s!(self.try_receiver()).sink()) }
-
-    /// Collect the metrics in Prometheus format.
-    pub fn collect_prometheus_format(&self) -> Result<String, String> {
-        let receiver = try_s!(self.try_receiver());
-        let controller = receiver.controller();
-
-        let mut observer = PrometheusBuilder::new().set_quantiles(QUANTILES).build();
-        controller.observe(&mut observer);
-
-        Ok(observer.drain())
-    }
-}
-
-type MetricName = ScopedString;
-
-type MetricLabels = Vec<Label>;
-
-type MetricNameValueMap = HashMap<MetricName, Integer>;
-
-#[derive(Clone, Eq, PartialEq, PartialOrd, Ord)]
-enum Integer {
-    Signed(i64),
-    Unsigned(u64),
-}
-
-impl fmt::Display for Integer {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Integer::Signed(x) => write!(f, "{}", x),
-            Integer::Unsigned(x) => write!(f, "{}", x),
-        }
-    }
-}
-
-struct PreparedMetric {
-    tags: Vec<Tag>,
-    message: String,
-}
-
-/// Observes metrics and histograms in Tag format.
-struct TagObserver {
-    /// Supported quantiles like Min, 0.5, 0.8, Max
-    quantiles: Vec<Quantile>,
-    /// Metric:Value pair matching an unique set of labels.
-    metrics: HashMap<MetricLabels, MetricNameValueMap>,
-    /// Histograms present set of time measurements and analysis over the measurements
-    histograms: HashMap<Key, Histogram<u64>>,
-}
-
-impl TagObserver {
-    fn new(quantiles: &[f64]) -> Self {
-        TagObserver {
-            quantiles: parse_quantiles(quantiles),
-            metrics: Default::default(),
-            histograms: Default::default(),
-        }
-    }
-
-    fn prepare_metrics(&self) -> Vec<PreparedMetric> {
-        self.metrics
-            .iter()
-            .map(|(labels, name_value_map)| {
-                let tags = labels_to_tags(labels.iter());
-                let message = name_value_map_to_message(name_value_map);
-
-                PreparedMetric { tags, message }
-            })
-            .collect()
-    }
-
-    fn prepare_histograms(&self) -> Vec<PreparedMetric> {
-        self.histograms
-            .iter()
-            .map(|(key, hist)| {
-                let tags = labels_to_tags(key.labels());
-                let message = format!("{}: {}", key.name(), hist_to_message(hist, &self.quantiles));
-
-                PreparedMetric { tags, message }
-            })
-            .collect()
-    }
-
-    fn insert_metric(&mut self, key: Key, value: Integer) {
-        let (name, labels) = key.into_parts();
-        self.metrics
-            .entry(labels)
-            .and_modify(|name_value_map| {
-                name_value_map.insert(name.clone(), value.clone());
-            })
-            .or_insert({
-                let mut name_value_map = HashMap::new();
-                name_value_map.insert(name, value);
-                name_value_map
-            });
-    }
-
-    /// Clear metrics or histograms if it's necessary
-    /// after an exporter has turned the observer's metrics and histograms.
-    fn on_turned(&mut self) {
-        // clear histograms because they can be duplicated
-        self.histograms.clear();
-        // don't clear metrics because the keys don't changes often
-    }
-}
-
-impl Observer for TagObserver {
-    fn observe_counter(&mut self, key: Key, value: u64) { self.insert_metric(key, Integer::Unsigned(value)) }
-
-    fn observe_gauge(&mut self, key: Key, value: i64) { self.insert_metric(key, Integer::Signed(value)) }
-
-    fn observe_histogram(&mut self, key: Key, values: &[u64]) {
-        let entry = self.histograms.entry(key).or_insert({
-            // Use default significant figures value.
-            // For more info on `sigfig` see the Historgam::new_with_bounds().
-            let sigfig = 3;
-            match Histogram::new(sigfig) {
-                Ok(x) => x,
-                Err(err) => {
-                    error!("failed to create histogram: {}", err);
-                    // do nothing on error
-                    return;
-                },
-            }
-        });
-
-        for value in values {
-            if let Err(err) = entry.record(*value) {
-                error!("failed to observe histogram value: {}", err);
-            }
-        }
-    }
-}
-
-/// Observes metrics and histograms in Tag format.
-struct JsonObserver {
-    /// Supported quantiles like Min, 0.5, 0.8, Max.
-    quantiles: Vec<Quantile>,
-    /// Collected metrics and histograms as serializable and deserializable structure.
-    metrics: MetricsJson,
-}
-
-impl Observer for JsonObserver {
-    fn observe_counter(&mut self, key: Key, value: u64) {
-        let (key, labels) = key.into_parts();
-
-        let metric = MetricType::Counter {
-            key: key.to_string(),
-            labels: labels_into_parts(labels.iter()),
-            value,
-        };
-
-        self.metrics.metrics.push(metric);
-    }
-
-    fn observe_gauge(&mut self, key: Key, value: i64) {
-        let (key, labels) = key.into_parts();
-
-        let metric = MetricType::Gauge {
-            key: key.to_string(),
-            labels: labels_into_parts(labels.iter()),
-            value,
-        };
-
-        self.metrics.metrics.push(metric);
-    }
-
-    fn observe_histogram(&mut self, key: Key, values: &[u64]) {
-        let (key, labels) = key.into_parts();
-
-        // Use default significant figures value.
-        // For more info on `sigfig` see the Historgam::new_with_bounds().
-        let sigfig = 3;
-        let mut histogram = match Histogram::new(sigfig) {
-            Ok(x) => x,
-            Err(err) => {
-                error!("failed to create histogram: {}", err);
-                // do nothing on error
-                return;
-            },
-        };
-
-        for value in values {
-            if let Err(err) = histogram.record(*value) {
-                error!("failed to observe histogram value: {}", err);
-            }
-        }
-
-        let count = histogram.len() as u64;
-        let mut quantiles = hist_at_quantiles(histogram, &self.quantiles);
-        // add total quantiles number
-        quantiles.insert("count".into(), count);
-
-        let metric = MetricType::Histogram {
-            key: key.to_string(),
-            labels: labels_into_parts(labels.iter()),
-            quantiles,
-        };
-
-        self.metrics.metrics.push(metric);
-    }
-}
-
-impl JsonObserver {
-    fn new(quantiles: &[f64]) -> Self {
-        JsonObserver {
-            quantiles: parse_quantiles(quantiles),
-            metrics: Default::default(),
-        }
-    }
-
-    fn into_json(self) -> Result<Json, String> { json::to_value(self.metrics).map_err(|err| ERRL!("{}", err)) }
-}
-
-/// Exports metrics by converting them to a Tag format and log them using log::Status.
-struct TagExporter<C> {
-    /// Using a weak reference by default in order to avoid circular references and leaks.
-    log_state: LogWeak,
-    /// Handle for acquiring metric snapshots.
-    controller: C,
-    /// Handle for converting snapshots into log.
-    observer: TagObserver,
-}
-
-impl<C> TagExporter<C>
-where
-    C: Observe,
-{
-    /// Run endless async loop
-    async fn run(mut self, interval: f64) {
-        loop {
-            Timer::sleep(interval).await;
-            self.turn();
-        }
-    }
-
-    /// Observe metrics and histograms and record it into the log in Tag format
-    fn turn(&mut self) {
-        let log_state = match LogArc::from_weak(&self.log_state) {
-            Some(x) => x,
-            // MmCtx is dropped already
-            _ => return,
-        };
-
-        log!(">>>>>>>>>> DEX metrics <<<<<<<<<");
-
-        // Observe means fill the observer's metrics and histograms with actual values
-        self.controller.observe(&mut self.observer);
-
-        for PreparedMetric { tags, message } in self.observer.prepare_metrics() {
-            log_state.log_deref_tags("", tags, &message);
-        }
-
-        for PreparedMetric { tags, message } in self.observer.prepare_histograms() {
-            log_state.log_deref_tags("", tags, &message);
-        }
-
-        self.observer.on_turned();
-    }
-}
-
-fn labels_to_tags(labels: Iter<Label>) -> Vec<Tag> {
-    labels
-        .map(|label| Tag {
-            key: label.key().to_string(),
-            val: Some(label.value().to_string()),
-        })
-        .collect()
-}
-
-fn labels_into_parts(labels: Iter<Label>) -> HashMap<String, String> {
-    labels
-        .map(|label| (label.key().to_string(), label.value().to_string()))
-        .collect()
-}
-
-fn name_value_map_to_message(name_value_map: &MetricNameValueMap) -> String {
-    name_value_map
-        .iter()
-        .sorted()
-        .map(|(key, value)| format!("{}={}", key, value))
-        .join(" ")
-}
-
-fn hist_at_quantiles(hist: Histogram<u64>, quantiles: &[Quantile]) -> HashMap<String, u64> {
-    quantiles
-        .iter()
-        .map(|quantile| {
-            let key = quantile.label().to_string();
-            let val = hist.value_at_quantile(quantile.value());
-            (key, val)
-        })
-        .collect()
-}
-
-fn hist_to_message(hist: &Histogram<u64>, quantiles: &[Quantile]) -> String {
-    if quantiles.is_empty() {
-        return format!("count={}", hist.len());
-    }
-
-    let fmt_quantiles = quantiles
-        .iter()
-        .map(|quantile| {
-            let key = quantile.label().to_string();
-            let val = hist.value_at_quantile(quantile.value());
-            format!("{}={}", key, val)
-        })
-        .join(" ");
-    format!("count={} {}", hist.len(), fmt_quantiles)
-}
-
-pub mod prometheus {
-    use super::*;
-    use futures::future::{Future, FutureExt};
-    use hyper::http::{self, header, Request, Response, StatusCode};
-    use hyper::service::{make_service_fn, service_fn};
-    use hyper::{Body, Server};
-    use std::convert::Infallible;
-    use std::net::SocketAddr;
-
-    #[derive(Clone)]
-    pub struct PrometheusCredentials {
-        pub userpass: String,
-    }
-
-    pub fn spawn_prometheus_exporter(
-        metrics: MetricsWeak,
-        address: SocketAddr,
-        shutdown_detector: impl Future<Output = ()> + 'static + Send,
-        credentials: Option<PrometheusCredentials>,
-    ) -> Result<(), String> {
-        let make_svc = make_service_fn(move |_conn| {
-            let metrics = metrics.clone();
-            let credentials = credentials.clone();
-            futures::future::ready(Ok::<_, Infallible>(service_fn(move |req| {
-                futures::future::ready(scrape_handle(req, metrics.clone(), credentials.clone()))
-            })))
-        });
-
-        let server = try_s!(Server::try_bind(&address))
-            .http1_half_close(false) // https://github.com/hyperium/hyper/issues/1764
-            .serve(make_svc)
-            .with_graceful_shutdown(shutdown_detector);
-
-        let server = server.then(|r| {
-            if let Err(err) = r {
-                error!("{}", err);
-            };
-            futures::future::ready(())
-        });
-
-        spawn(server);
-        Ok(())
-    }
-
-    fn scrape_handle(
-        req: Request<Body>,
-        metrics: MetricsWeak,
-        credentials: Option<PrometheusCredentials>,
-    ) -> Result<Response<Body>, http::Error> {
-        fn on_error(status: StatusCode, error: String) -> Result<Response<Body>, http::Error> {
-            error!("{}", error);
-            Response::builder().status(status).body(Body::empty()).map_err(|err| {
-                error!("{}", err);
-                err
-            })
-        }
-
-        if req.uri() != "/metrics" {
-            return on_error(
-                StatusCode::BAD_REQUEST,
-                ERRL!("Warning Prometheus: unexpected URI {}", req.uri()),
-            );
-        }
-
-        if let Some(credentials) = credentials {
-            if let Err(err) = check_auth_credentials(&req, credentials) {
-                return on_error(StatusCode::UNAUTHORIZED, err);
-            }
-        }
-
-        let metrics = match MetricsArc::from_weak(&metrics) {
-            Some(m) => m,
-            _ => {
-                return on_error(
-                    StatusCode::BAD_REQUEST,
-                    ERRL!("Warning Prometheus: metrics system unavailable"),
-                )
-            },
-        };
-
-        let body = match metrics.0.collect_prometheus_format() {
-            Ok(body) => Body::from(body),
-            _ => {
-                return on_error(
-                    StatusCode::BAD_REQUEST,
-                    ERRL!("Warning Prometheus: metrics system is not initialized yet"),
-                )
-            },
-        };
-
-        Response::builder()
-            .status(StatusCode::OK)
-            .header(header::CONTENT_TYPE, "text/plain")
-            .body(body)
-            .map_err(|err| {
-                error!("{}", err);
-                err
-            })
-    }
-
-    fn check_auth_credentials(req: &Request<Body>, expected: PrometheusCredentials) -> Result<(), String> {
-        let header_value = req
-            .headers()
-            .get(header::AUTHORIZATION)
-            .ok_or(ERRL!("Warning Prometheus: authorization required"))
-            .and_then(|header| Ok(try_s!(header.to_str())))?;
-
-        let expected = format!("Basic {}", base64::encode_config(&expected.userpass, base64::URL_SAFE));
-
-        if header_value != expected {
-            return Err(format!("Warning Prometheus: invalid credentials: {}", header_value));
-        }
-
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::block_on;
-    use crate::log::LogState;
-
-    #[test]
-    fn test_initialization() {
-        let log_state = LogArc::new(LogState::in_memory());
-        let metrics = MetricsArc::new();
-
-        // metrics system is not initialized yet
-        assert!(metrics.try_sink().is_none());
-
-        metrics.init().unwrap();
-        assert!(metrics.init().is_err());
-        assert!(metrics.init_with_dashboard(log_state.weak(), 1.).is_err());
-
-        assert!(metrics.try_sink().is_some());
-    }
-
-    #[test]
-    #[ignore]
-    fn test_dashboard() {
-        let log_state = LogArc::new(LogState::in_memory());
-        let metrics = MetricsArc::new();
-
-        metrics.init_with_dashboard(log_state.weak(), 5.).unwrap();
-        let clock = metrics.clock().unwrap();
-
-        let start = clock.now();
-
-        mm_counter!(metrics, "rpc.traffic.tx", 62, "coin" => "BTC");
-        mm_counter!(metrics, "rpc.traffic.rx", 105, "coin"=> "BTC");
-
-        mm_counter!(metrics, "rpc.traffic.tx", 54, "coin" => "KMD");
-        mm_counter!(metrics, "rpc.traffic.rx", 158, "coin" => "KMD");
-
-        mm_gauge!(metrics, "rpc.connection.count", 3, "coin" => "KMD");
-
-        let end = clock.now();
-        mm_timing!(metrics,
-                   "rpc.query.spent_time",
-                   start,
-                   end,
-                   "coin" => "KMD",
-                   "method" => "blockchain.transaction.get");
-
-        block_on(async { Timer::sleep(6.).await });
-
-        mm_counter!(metrics, "rpc.traffic.tx", 30, "coin" => "BTC");
-        mm_counter!(metrics, "rpc.traffic.rx", 44, "coin" => "BTC");
-
-        mm_gauge!(metrics, "rpc.connection.count", 5, "coin" => "KMD");
-
-        let end = clock.now();
-        mm_timing!(metrics,
-                   "rpc.query.spent_time",
-                   start,
-                   end,
-                   "coin"=> "KMD",
-                   "method"=>"blockchain.transaction.get");
-
-        // measure without labels
-        mm_counter!(metrics, "test.counter", 0);
-        mm_gauge!(metrics, "test.gauge", 1);
-        let end = clock.now();
-        mm_timing!(metrics, "test.uptime", start, end);
-
-        block_on(async { Timer::sleep(6.).await });
-    }
-
-    /// There is a problem inside the `metrics` crate:
-    /// histograms are lost or ignored sometimes when `metrics::Controller::observe` is called.
-    /// Because of this, the `mm_timing` macro usage is commented out.
-    #[test]
-    fn test_collect_json() {
-        let metrics = MetricsArc::new();
-
-        metrics.init().unwrap();
-
-        mm_counter!(metrics, "rpc.traffic.tx", 62, "coin" => "BTC");
-        mm_counter!(metrics, "rpc.traffic.rx", 105, "coin" => "BTC");
-
-        mm_counter!(metrics, "rpc.traffic.tx", 30, "coin" => "BTC");
-        mm_counter!(metrics, "rpc.traffic.rx", 44, "coin" => "BTC");
-
-        mm_counter!(metrics, "rpc.traffic.tx", 54, "coin" => "KMD");
-        mm_counter!(metrics, "rpc.traffic.rx", 158, "coin" => "KMD");
-
-        mm_gauge!(metrics, "rpc.connection.count", 3, "coin" => "KMD");
-
-        // counter, gauge and timing may be collected also by sink API
-        mm_gauge!(metrics, "rpc.connection.count", 5, "coin" => "KMD");
-
-        // mm_timing!(metrics,
-        //            "rpc.query.spent_time",
-        //            // ~ 1 second
-        //            34381019796149, // start
-        //            34382022725155, // end
-        //            "coin" => "KMD",
-        //            "method" => "blockchain.transaction.get");
-        //
-        // mm_timing!(metrics,
-        //            "rpc.query.spent_time",
-        //            // ~ 2 second
-        //            34382022774105, // start
-        //            34384023173373, // end
-        //            "coin" => "KMD",
-        //            "method" => "blockchain.transaction.get");
-
-        let expected = json!({
-            "metrics": [
-                {
-                    "key": "rpc.traffic.tx",
-                    "labels": { "coin": "BTC" },
-                    "type": "counter",
-                    "value": 92
-                },
-                {
-                    "key": "rpc.traffic.rx",
-                    "labels": { "coin": "BTC" },
-                    "type": "counter",
-                    "value": 149
-                },
-                {
-                    "key": "rpc.traffic.tx",
-                    "labels": { "coin": "KMD" },
-                    "type": "counter",
-                    "value": 54
-                },
-                {
-                    "key": "rpc.traffic.rx",
-                    "labels": { "coin": "KMD" },
-                    "type": "counter",
-                    "value": 158
-                },
-                // {
-                //     "count": 2,
-                //     "key": "rpc.query.spent_time",
-                //     "labels": { "coin": "KMD", "method": "blockchain.transaction.get" },
-                //     "max": 2000683007,
-                //     "min": 1002438656,
-                //     "type": "histogram"
-                // },
-                {
-                    "key": "rpc.connection.count",
-                    "labels": { "coin": "KMD" },
-                    "type": "gauge",
-                    "value": 5
-                }
-            ]
-        });
-
-        let mut actual = metrics.collect_json().unwrap();
-
-        let actual = actual["metrics"].as_array_mut().unwrap();
-        for expected in expected["metrics"].as_array().unwrap() {
-            let index = actual.iter().position(|metric| metric == expected).expect(&format!(
-                "Couldn't find expected metric: {:?} in {:?}",
-                expected, actual
-            ));
-            actual.remove(index);
-        }
-
-        assert!(
-            actual.is_empty(),
-            "More metrics collected than expected. Excess metrics: {:?}",
-            actual
-        );
-    }
-}
diff --git a/mm2src/common/mm_metrics/wasm.rs b/mm2src/common/mm_metrics/wasm.rs
deleted file mode 100644
index b2d6eb33e8..0000000000
--- a/mm2src/common/mm_metrics/wasm.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-use super::*;
-use crate::now_ms;
-
-/// The dummy macro that imitates [`crate::mm_metrics::native::mm_counter`].
-/// These macros borrow the `$metrics`, `$name`, `$value` and takes ownership of the `$label_key`, `$label_val` to prevent the `unused_variable` warning.
-/// The labels have to be moved because [`metrics_runtime::Sink::increment_counter_with_labels`] also takes ownership of the labels.
-#[macro_export]
-macro_rules! mm_counter {
-    ($metrics:expr, $name:expr, $value:expr) => {{
-        let _ = (&$metrics, &$name, &$value); // borrow
-    }};
-    ($metrics:expr, $name:expr, $value:expr, $($label_key:expr => $label_val:expr),+) => {{
-        let _ = (&$metrics, &$name, &$value); // borrow
-        let _ = ($($label_key, $label_val),+); // move
-    }};
-}
-
-/// The dummy macro that imitates [`crate::mm_metrics::native::mm_gauge`].
-/// These macros borrow the `$metrics`, `$name`, `$value` and takes ownership of the `$label_key`, `$label_val` to prevent the `unused_variable` warning.
-/// The labels have to be moved because [`metrics_runtime::Sink::update_gauge_with_labels`] also takes ownership of the labels.
-#[macro_export]
-macro_rules! mm_gauge {
-    ($metrics:expr, $name:expr, $value:expr) => {{
-        let _ = (&$metrics, &$name, &$value); // borrow
-    }};
-    ($metrics:expr, $name:expr, $value:expr, $($label_key:expr => $label_val:expr),+) => {{
-        let _ = (&$metrics, &$name, &$value); // borrow
-        let _ = ($($label_key, $label_val),+); // move
-    }};
-}
-
-/// The dummy macro that imitates [`crate::mm_metrics::native::mm_timing`].
-/// These macros borrow the `$metrics`, `$name`, `$start`, `$end` and takes ownership of the `$label_key`, `$label_val` to prevent the `unused_variable` warning.
-/// The labels have to be moved because [`metrics_runtime::Sink::record_timing_with_labels`] also takes ownership of the labels.
-#[macro_export]
-macro_rules! mm_timing {
-    ($metrics:expr, $name:expr, $start:expr, $end:expr) => {{
-        let _ = (&$metrics, &$name, &$start, &$end); // borrow
-    }};
-    ($metrics:expr, $name:expr, $start:expr, $end:expr, $($label_key:expr => $label_val:expr),+) => {{
-        let _ = (&$metrics, &$name, &$start, &$end); // borrow
-        let _ = ($($label_key, $label_val),+); // move
-    }};
-}
-
-#[derive(Default)]
-pub struct Clock {}
-
-impl ClockOps for Clock {
-    fn now(&self) -> u64 { now_ms() }
-}
-
-#[derive(Default)]
-pub struct Metrics {}
-
-impl MetricsOps for Metrics {
-    fn init(&self) -> Result<(), String> { Ok(()) }
-
-    fn init_with_dashboard(&self, _log_state: LogWeak, _record_interval: f64) -> Result<(), String> { Ok(()) }
-
-    fn clock(&self) -> Result<Clock, String> { Ok(Clock::default()) }
-
-    fn collect_json(&self) -> Result<Json, String> { Ok(Json::Array(Vec::new())) }
-}
diff --git a/mm2src/mm2_core/Cargo.toml b/mm2src/mm2_core/Cargo.toml
index 0624806623..b260692076 100644
--- a/mm2src/mm2_core/Cargo.toml
+++ b/mm2src/mm2_core/Cargo.toml
@@ -17,6 +17,7 @@ futures = { version = "0.3", package = "futures", features = ["compat", "async-a
 hex = "0.4.2"
 keys = { path = "../mm2_bitcoin/keys" }
 lazy_static = "1.4"
+mm2_metrics = { path = "../mm2_metrics" }
 primitives = { path = "../mm2_bitcoin/primitives" }
 rand = { version = "0.7", features = ["std", "small_rng", "wasm-bindgen"] }
 serde = "1"
diff --git a/mm2src/mm2_core/src/mm_ctx.rs b/mm2src/mm2_core/src/mm_ctx.rs
index 6278d71647..e850d4cbf2 100644
--- a/mm2src/mm2_core/src/mm_ctx.rs
+++ b/mm2src/mm2_core/src/mm_ctx.rs
@@ -2,12 +2,12 @@ use arrayref::array_ref;
 #[cfg(any(not(target_arch = "wasm32"), feature = "track-ctx-pointer"))]
 use common::executor::Timer;
 use common::log::{self, LogLevel, LogState};
-use common::mm_metrics::{MetricsArc, MetricsOps};
 use common::{bits256, cfg_native, cfg_wasm32, small_rng};
 use futures::future::AbortHandle;
 use gstuff::{try_s, Constructible, ERR, ERRL};
 use keys::KeyPair;
 use lazy_static::lazy_static;
+use mm2_metrics::{MetricsArc, MetricsOps, MmMetricsError};
 use primitives::hash::H160;
 use rand::Rng;
 use serde::{Deserialize, Serialize};
@@ -18,6 +18,7 @@ use std::any::Any;
 use std::collections::hash_map::{Entry, HashMap};
 use std::collections::HashSet;
 use std::fmt;
+use std::net::AddrParseError;
 use std::ops::Deref;
 use std::path::{Path, PathBuf};
 use std::sync::{Arc, Mutex};
@@ -28,7 +29,7 @@ cfg_wasm32! {
 }
 
 cfg_native! {
-    use common::mm_metrics::prometheus;
+    use mm2_metrics::prometheus;
     use db_common::sqlite::rusqlite::Connection;
     use std::net::{IpAddr, SocketAddr};
     use std::sync::MutexGuard;
@@ -479,7 +480,7 @@ impl MmArc {
             .unwrap_or(EXPORT_METRICS_INTERVAL);
 
         if interval == 0.0 {
-            try_s!(self.metrics.init());
+            self.metrics.init();
         } else {
             try_s!(self.metrics.init_with_dashboard(self.log.weak(), interval));
         }
@@ -491,13 +492,15 @@ impl MmArc {
     }
 
     #[cfg(not(target_arch = "wasm32"))]
-    fn spawn_prometheus_exporter(&self) -> Result<(), String> {
+    fn spawn_prometheus_exporter(&self) -> Result<(), MmMetricsError> {
         let prometheusport = match self.conf["prometheusport"].as_u64() {
             Some(port) => port,
             _ => return Ok(()),
         };
 
-        let address: SocketAddr = try_s!(format!("127.0.0.1:{}", prometheusport).parse());
+        let address: SocketAddr = format!("127.0.0.1:{}", prometheusport)
+            .parse()
+            .map_err(|e: AddrParseError| MmMetricsError::PrometheusServerError(e.to_string()))?;
 
         let credentials =
             self.conf["prometheus_credentials"]
diff --git a/mm2src/mm2_main/Cargo.toml b/mm2src/mm2_main/Cargo.toml
index 95d1842d6b..c785f49866 100644
--- a/mm2src/mm2_main/Cargo.toml
+++ b/mm2src/mm2_main/Cargo.toml
@@ -73,11 +73,11 @@ keys = { path = "../mm2_bitcoin/keys" }
 lazy_static = "1.4"
 # ledger = { path = "../ledger" }
 libc = "0.2"
-metrics = "0.12"
 mm2_core = { path = "../mm2_core" }
 mm2_err_handle = { path = "../mm2_err_handle" }
 mm2_io = { path = "../mm2_io" }
 mm2-libp2p = { path = "../mm2_libp2p" }
+mm2_metrics = { path = "../mm2_metrics" }
 mm2_net = { path = "../mm2_net" }
 mm2_number = { path = "../mm2_number" }
 mm2_rpc = { path = "../mm2_rpc" }
diff --git a/mm2src/mm2_main/src/lp_native_dex.rs b/mm2src/mm2_main/src/lp_native_dex.rs
index a9e0fe72a5..a06b9c03fd 100644
--- a/mm2src/mm2_main/src/lp_native_dex.rs
+++ b/mm2src/mm2_main/src/lp_native_dex.rs
@@ -27,6 +27,7 @@ use derive_more::Display;
 use mm2_core::mm_ctx::{MmArc, MmCtx};
 use mm2_err_handle::prelude::*;
 use mm2_libp2p::{spawn_gossipsub, AdexBehaviourError, NodeType, RelayAddress, RelayAddressError, WssCerts};
+use mm2_metrics::mm_gauge;
 use rpc_task::RpcTaskError;
 use serde_json::{self as json};
 use std::fs;
@@ -471,28 +472,28 @@ pub async fn init_p2p(ctx: MmArc) -> P2PResult<()> {
         mm_gauge!(
             ctx_on_poll.metrics,
             "p2p.connected_relays.len",
-            behaviour.connected_relays_len() as i64
+            behaviour.connected_relays_len() as f64
         );
         mm_gauge!(
             ctx_on_poll.metrics,
             "p2p.relay_mesh.len",
-            behaviour.relay_mesh_len() as i64
+            behaviour.relay_mesh_len() as f64
         );
         let (period, received_msgs) = behaviour.received_messages_in_period();
         mm_gauge!(
             ctx_on_poll.metrics,
             "p2p.received_messages.period_in_secs",
-            period.as_secs() as i64
+            period.as_secs() as f64
         );
 
-        mm_gauge!(ctx_on_poll.metrics, "p2p.received_messages.count", received_msgs as i64);
+        mm_gauge!(ctx_on_poll.metrics, "p2p.received_messages.count", received_msgs as f64);
 
         let connected_peers_count = behaviour.connected_peers_len();
 
         mm_gauge!(
             ctx_on_poll.metrics,
             "p2p.connected_peers.count",
-            connected_peers_count as i64
+            connected_peers_count as f64
         );
     })
     .await;
diff --git a/mm2src/mm2_main/src/lp_network.rs b/mm2src/mm2_main/src/lp_network.rs
index b5e81360b4..51cabeec7d 100644
--- a/mm2src/mm2_main/src/lp_network.rs
+++ b/mm2src/mm2_main/src/lp_network.rs
@@ -20,7 +20,6 @@
 //
 use coins::lp_coinfind;
 use common::executor::spawn;
-use common::mm_metrics::{ClockOps, MetricsOps};
 use common::{log, Future01CompatExt};
 use derive_more::Display;
 use futures::{channel::oneshot, StreamExt};
@@ -32,11 +31,13 @@ use mm2_libp2p::atomicdex_behaviour::{AdexBehaviourCmd, AdexBehaviourEvent, Adex
 use mm2_libp2p::peers_exchange::PeerAddresses;
 use mm2_libp2p::{decode_message, encode_message, DecodingError, GossipsubMessage, Libp2pPublic, Libp2pSecpPublic,
                  MessageId, NetworkPorts, PeerId, TOPIC_SEPARATOR};
+use mm2_metrics::{mm_label, mm_timing};
 #[cfg(test)] use mocktopus::macros::*;
 use parking_lot::Mutex as PaMutex;
 use serde::de;
 use std::net::ToSocketAddrs;
 use std::sync::Arc;
+use wasm_timer::Instant;
 
 use crate::mm2::{lp_ordermatch, lp_stats, lp_swap};
 
@@ -326,11 +327,10 @@ pub async fn request_one_peer<T: de::DeserializeOwned>(
     req: P2PRequest,
     peer: String,
 ) -> P2PRequestResult<Option<T>> {
-    let clock = ctx.metrics.clock().expect("Metrics clock is not available");
-    let start = clock.now();
+    let start = Instant::now();
     let mut responses = request_peers::<T>(ctx.clone(), req, vec![peer.clone()]).await?;
-    let end = clock.now();
-    mm_timing!(ctx.metrics, "peer.outgoing_request.timing", start, end, "peer" => peer);
+    let elapsed = start.elapsed();
+    mm_timing!(ctx.metrics, "peer.outgoing_request.timing", elapsed, "peer" => peer);
     if responses.len() != 1 {
         return MmError::err(P2PRequestError::ExpectedSingleResponseError(responses.len()));
     }
diff --git a/mm2src/mm2_main/src/lp_ordermatch.rs b/mm2src/mm2_main/src/lp_ordermatch.rs
index 0ab47bfa60..170013599a 100644
--- a/mm2src/mm2_main/src/lp_ordermatch.rs
+++ b/mm2src/mm2_main/src/lp_ordermatch.rs
@@ -42,6 +42,7 @@ use keys::{AddressFormat, KeyPair};
 use mm2_core::mm_ctx::{from_ctx, MmArc, MmWeak};
 use mm2_err_handle::prelude::*;
 use mm2_libp2p::{decode_signed, encode_and_sign, encode_message, pub_sub_topic, TopicPrefix, TOPIC_SEPARATOR};
+use mm2_metrics::{mm_gauge, mm_label};
 use mm2_number::{construct_detailed, BigDecimal, BigRational, Fraction, MmNumber, MmNumberMultiRepr};
 #[cfg(test)] use mocktopus::macros::*;
 use num_traits::identities::Zero;
@@ -2380,13 +2381,13 @@ fn collect_orderbook_metrics(ctx: &MmArc, orderbook: &Orderbook) {
     }
 
     let memory_db_size = malloc_size(&orderbook.memory_db);
-    mm_gauge!(ctx.metrics, "orderbook.len", orderbook.order_set.len() as i64);
-    mm_gauge!(ctx.metrics, "orderbook.memory_db", memory_db_size as i64);
+    mm_gauge!(ctx.metrics, "orderbook.len", orderbook.order_set.len() as f64);
+    mm_gauge!(ctx.metrics, "orderbook.memory_db", memory_db_size as f64);
 
     // TODO remove metrics below after testing
     for (pubkey, pubkey_state) in orderbook.pubkeys_state.iter() {
-        mm_gauge!(ctx.metrics, "orders_uuids", pubkey_state.orders_uuids.len() as i64, "pubkey" => pubkey.clone());
-        mm_gauge!(ctx.metrics, "history.commited_changes", history_committed_changes(&pubkey_state.order_pairs_trie_state_history), "pubkey" => pubkey.clone());
+        mm_gauge!(ctx.metrics, "orders_uuids", pubkey_state.orders_uuids.len() as f64, "pubkey" => pubkey.clone());
+        mm_gauge!(ctx.metrics, "history.commited_changes", history_committed_changes(&pubkey_state.order_pairs_trie_state_history) as f64, "pubkey" => pubkey.clone());
     }
 }
 
diff --git a/mm2src/mm2_main/src/mm2_tests.rs b/mm2src/mm2_main/src/mm2_tests.rs
index c7f37cf10d..fe99542461 100644
--- a/mm2src/mm2_main/src/mm2_tests.rs
+++ b/mm2src/mm2_main/src/mm2_tests.rs
@@ -1,11 +1,12 @@
 use super::{lp_main, LpMainParams};
 use crate::mm2::lp_ordermatch::MIN_ORDER_KEEP_ALIVE_INTERVAL;
+
 use common::executor::Timer;
 use common::log::LogLevel;
-use common::mm_metrics::{MetricType, MetricsJson};
 use common::now_ms;
 use crypto::privkey::key_pair_from_seed;
 use http::{HeaderMap, StatusCode};
+use mm2_metrics::{MetricType, MetricsJson};
 use mm2_number::{BigDecimal, BigRational, Fraction, MmNumber};
 use mm2_test_helpers::for_tests::{check_my_swap_status, check_recent_swaps, check_stats_swap_status,
                                   enable_native as enable_native_impl, enable_qrc20, find_metrics_in_json,
diff --git a/mm2src/mm2_main/src/rpc/lp_commands/lp_commands_legacy.rs b/mm2src/mm2_main/src/rpc/lp_commands/lp_commands_legacy.rs
index d78d756f4a..ad4b6c527c 100644
--- a/mm2src/mm2_main/src/rpc/lp_commands/lp_commands_legacy.rs
+++ b/mm2src/mm2_main/src/rpc/lp_commands/lp_commands_legacy.rs
@@ -22,11 +22,11 @@
 use coins::{disable_coin as disable_coin_impl, lp_coinfind, lp_coininit, MmCoinEnum};
 use common::executor::{spawn, Timer};
 use common::log::error;
-use common::mm_metrics::MetricsOps;
 use common::{rpc_err_response, rpc_response, HyRes};
 use futures::compat::Future01CompatExt;
 use http::Response;
 use mm2_core::mm_ctx::MmArc;
+use mm2_metrics::MetricsOps;
 use mm2_number::{construct_detailed, BigDecimal};
 use serde_json::{self as json, Value as Json};
 use std::borrow::Cow;
@@ -177,7 +177,7 @@ pub fn help() -> HyRes {
 pub fn metrics(ctx: MmArc) -> HyRes {
     match ctx.metrics.collect_json().map(|value| value.to_string()) {
         Ok(response) => rpc_response(200, response),
-        Err(err) => rpc_err_response(500, &err),
+        Err(err) => rpc_err_response(500, &err.to_string()),
     }
 }
 
diff --git a/mm2src/mm2_metrics/Cargo.toml b/mm2src/mm2_metrics/Cargo.toml
new file mode 100644
index 0000000000..9f2a424564
--- /dev/null
+++ b/mm2src/mm2_metrics/Cargo.toml
@@ -0,0 +1,27 @@
+[package]
+name = "mm2_metrics"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+base64 = "0.10.0"
+common = { path = "../common" }
+derive_more = "0.99"
+futures = { version = "0.3", package = "futures", features = ["compat", "async-await", "thread-pool"] }
+itertools = "0.10"
+metrics = { version = "0.19" }
+metrics-util = { version = "0.13" }
+mm2_err_handle = { path = "../mm2_err_handle" }
+serde = "1"
+serde_derive = "1"
+serde_json = { version = "1.0", features = ["preserve_order", "raw_value"] }
+wasm-timer = "0.2.4"
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+hyper = { version = "0.14.11", features = ["client", "http2", "server", "tcp"] }
+# using webpki-tokio to avoid rejecting valid certificates
+# got "invalid certificate: UnknownIssuer" for https://ropsten.infura.io on iOS using default-features
+hyper-rustls = { version = "0.23", default-features = false, features = ["http1", "http2", "webpki-tokio"] }
+metrics-exporter-prometheus = "0.10.0"
diff --git a/mm2src/mm2_metrics/src/lib.rs b/mm2src/mm2_metrics/src/lib.rs
new file mode 100644
index 0000000000..9275e0a407
--- /dev/null
+++ b/mm2src/mm2_metrics/src/lib.rs
@@ -0,0 +1,125 @@
+#[macro_use] extern crate common;
+#[macro_use] extern crate serde_derive;
+
+#[macro_use]
+pub mod mm_metrics;
+pub mod recorder;
+pub use metrics;
+#[cfg(not(target_arch = "wasm32"))]
+pub use mm_metrics::prometheus;
+
+use common::log::LogWeak;
+use derive_more::Display;
+use mm2_err_handle::prelude::MmError;
+use mm_metrics::Metrics;
+use recorder::{MmRecorder, TryRecorder};
+use serde_json::Value as Json;
+use std::collections::HashMap;
+use std::sync::{Arc, Weak};
+
+pub type MmMetricsResult<T> = Result<T, MmError<MmMetricsError>>;
+
+#[derive(Debug, Display)]
+pub enum MmMetricsError {
+    #[display(fmt = "Internal: {}", _0)]
+    Internal(String),
+    #[display(fmt = "Warning Prometheus: metrics system unavailable")]
+    MetricsSystemUnavailable,
+    #[display(fmt = "Warning Prometheus: authorization required")]
+    PrometheusAuthorizationRequired,
+    #[display(fmt = "Warning Prometheus: invalid credentials: {}", _0)]
+    PrometheusInvalidCredentials(String),
+    #[display(fmt = "Prometheus Server Error: {}", _0)]
+    PrometheusServerError(String),
+    #[display(fmt = "Warning Prometheus: unexpected URI {}", _0)]
+    UnexpectedUri(String),
+}
+
+pub trait MetricsOps {
+    /// Initializes mm2 Metrics.
+    fn init(&self)
+    where
+        Self: Sized;
+
+    /// Initializes mm2 Metrics with dashboard.
+    fn init_with_dashboard(&self, log_state: LogWeak, interval: f64) -> MmMetricsResult<()>;
+
+    /// Collect the metrics in a Json data format.
+    fn collect_json(&self) -> MmMetricsResult<crate::Json>;
+}
+
+#[derive(Clone)]
+pub struct MetricsArc(pub(crate) Arc<Metrics>);
+
+impl Default for MetricsArc {
+    fn default() -> Self { Self(Arc::new(Metrics::default())) }
+}
+
+impl MetricsArc {
+    // Create new instance of our metrics recorder set to default.
+    pub fn new() -> Self { Self(Default::default()) }
+
+    /// Try to obtain the `Metrics` from the weak pointer.
+    pub fn from_weak(weak: &MetricsWeak) -> Option<MetricsArc> { weak.0.upgrade().map(MetricsArc) }
+
+    /// Create a weak pointer from `MetricsWeak`.
+    pub fn weak(&self) -> MetricsWeak { MetricsWeak(Arc::downgrade(&self.0)) }
+}
+
+impl TryRecorder for MetricsArc {
+    fn try_recorder(&self) -> Option<Arc<MmRecorder>> { Some(Arc::clone(&self.0.recorder)) }
+}
+
+impl MetricsOps for MetricsArc {
+    fn init(&self) { self.0.init(); }
+
+    fn init_with_dashboard(&self, log_state: LogWeak, interval: f64) -> MmMetricsResult<()> {
+        self.0.init_with_dashboard(log_state, interval)
+    }
+
+    fn collect_json(&self) -> MmMetricsResult<crate::Json> { self.0.collect_json() }
+}
+
+#[derive(Clone, Default)]
+pub struct MetricsWeak(pub Weak<Metrics>);
+
+impl MetricsWeak {
+    /// Create a default MmWeak without allocating any memory.
+    pub fn new() -> MetricsWeak { MetricsWeak::default() }
+
+    pub fn dropped(&self) -> bool { self.0.strong_count() == 0 }
+}
+
+impl TryRecorder for MetricsWeak {
+    fn try_recorder(&self) -> Option<Arc<MmRecorder>> {
+        let metrics = MetricsArc::from_weak(self)?;
+        metrics.try_recorder()
+    }
+}
+
+#[derive(Serialize, Debug, Default, Deserialize)]
+pub struct MetricsJson {
+    pub metrics: Vec<MetricType>,
+}
+
+#[derive(Debug, Deserialize, PartialEq, Serialize)]
+#[serde(rename_all = "lowercase")]
+#[serde(tag = "type")]
+pub enum MetricType {
+    Counter {
+        key: String,
+        labels: HashMap<String, String>,
+        value: u64,
+    },
+    Gauge {
+        key: String,
+        labels: HashMap<String, String>,
+        value: f64,
+    },
+    Histogram {
+        key: String,
+        labels: HashMap<String, String>,
+        #[serde(flatten)]
+        quantiles: HashMap<String, f64>,
+    },
+}
diff --git a/mm2src/mm2_metrics/src/mm_metrics.rs b/mm2src/mm2_metrics/src/mm_metrics.rs
new file mode 100644
index 0000000000..c7eacab085
--- /dev/null
+++ b/mm2src/mm2_metrics/src/mm_metrics.rs
@@ -0,0 +1,554 @@
+use common::executor::{spawn, Timer};
+#[cfg(not(target_arch = "wasm32"))] use common::log::error;
+use common::log::{LogArc, LogWeak};
+use itertools::Itertools;
+use metrics::{Key, Label};
+use mm2_err_handle::prelude::*;
+use serde_json::Value;
+use std::sync::{atomic::Ordering, Arc};
+use std::{collections::HashMap, slice::Iter};
+
+use crate::MmMetricsError;
+use crate::{common::log::Tag, MetricsOps, MmMetricsResult, MmRecorder};
+
+type MetricLabels = Vec<Label>;
+type MetricNameValueMap = HashMap<String, PreparedMetric>;
+
+/// Construct Vec<Label> from a slice of strings.
+#[macro_export]
+macro_rules! mm_label {
+    ($($label_key:expr => $label_val:expr),+) => {{
+         vec![$(($label_key.to_owned(), $label_val.to_owned())),+]
+    }};
+}
+
+/// Increment counter if an MmArc is not dropped yet and metrics system is initialized already.
+#[macro_export]
+macro_rules! mm_counter {
+    ($metrics:expr, $name:expr, $value:expr) => {{
+        use $crate::metrics::Recorder;
+        if let Some(recorder) = $crate::recorder::TryRecorder::try_recorder(&$metrics) {
+            let key = $crate::metrics::Key::from_static_name($name);
+            let counter = recorder.register_counter(&key);
+            counter.increment($value);
+        };
+    }};
+
+    // Register and increment counter with label.
+    ($metrics:expr, $name:expr, $value:expr, $($label_key:expr => $label_val:expr),+) => {{
+        use $crate::metrics::Recorder;
+        if let Some(recorder) = $crate::recorder::TryRecorder::try_recorder(&$metrics) {
+            let key = $crate::metrics::Key::from_parts($name, mm_label!($($label_key => $label_val),+).as_slice());
+            let counter = recorder.register_counter(&key);
+            counter.increment($value);
+        };
+    }};
+}
+
+/// Update gauge if an MmArc is not dropped yet and metrics system is initialized already.
+#[macro_export]
+macro_rules! mm_gauge {
+    ($metrics:expr, $name:expr, $value:expr) => {{
+        use $crate::metrics::Recorder;
+        if let Some(recorder) = $crate::recorder::TryRecorder::try_recorder(&$metrics){
+            let key = $crate::metrics::Key::from_static_name($name);
+            let gauge = recorder.register_gauge(&key);
+            gauge.set($value);
+        }
+    }};
+
+    // Register and set gauge with label.
+    ($metrics:expr, $name:expr, $value:expr, $($label_key:expr => $label_val:expr),+) => {{
+        use $crate::metrics::Recorder;
+        if let Some(recorder) = $crate::recorder::TryRecorder::try_recorder(&$metrics){
+            let key = $crate::metrics::Key::from_parts($name, mm_label!($($label_key => $label_val),+).as_slice());
+            let gauge = recorder.register_gauge(&key);
+            gauge.set($value);
+        }
+    }};
+}
+
+/// Update gauge if an MmArc is not dropped yet and metrics system is initialized already.
+#[macro_export]
+macro_rules! mm_timing {
+    ($metrics:expr, $name:expr, $value:expr) => {{
+        use $crate::metrics::Recorder;
+        if let Some(recorder) = $crate::recorder::TryRecorder::try_recorder(&$metrics){
+            let key =$crate::metrics::Key::from_static_name($name);
+            let histo = recorder.register_histogram(&key);
+            histo.record($value);
+        }
+    }};
+
+    // Register and record histogram with label.
+    ($metrics:expr, $name:expr, $value:expr, $($label_key:expr => $label_val:expr),+) => {{
+        use $crate::metrics::Recorder;
+        if let Some(recorder) = $crate::recorder::TryRecorder::try_recorder(&$metrics){
+            let key = $crate::metrics::Key::from_parts($name, mm_label!($($label_key => $label_val),+).as_slice());
+            let histo = recorder.register_histogram(&key);
+            histo.record($value);
+        }
+    }};
+}
+
+/// Market Maker Metrics, used as inner to get metrics data and exporting.
+#[derive(Default, Clone)]
+pub struct Metrics {
+    pub(crate) recorder: Arc<MmRecorder>,
+}
+
+impl Metrics {
+    /// Collect the metrics in Prometheus format.
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn collect_prometheus_format(&self) -> String { self.recorder.render_prometheus() }
+}
+
+impl MetricsOps for Metrics {
+    fn init(&self) { Metrics::default(); }
+
+    fn init_with_dashboard(&self, log_state: LogWeak, interval: f64) -> MmMetricsResult<()> {
+        let recorder = self.recorder.clone();
+        let runner = TagObserver::log_tag_metrics(log_state, recorder, interval);
+        spawn(runner);
+        Ok(())
+    }
+
+    /// Collect prepared metrics json from the recorder.
+    fn collect_json(&self) -> MmMetricsResult<Value> {
+        serde_json::to_value(self.recorder.prepare_json()).map_to_mm(|err| MmMetricsError::Internal(err.to_string()))
+    }
+}
+
+#[derive(Debug)]
+pub struct TagMetric {
+    pub tags: Vec<Tag>,
+    pub message: String,
+}
+
+#[derive(PartialEq, PartialOrd)]
+pub(crate) enum PreparedMetric {
+    Unsigned(u64),
+    Float(f64),
+    Histogram(MmHistogram),
+}
+
+pub struct TagObserver;
+
+impl TagObserver {
+    /// This is for collecting and logging `prepare_tag_metrics` to dashboard.
+    ///
+    /// Used with `init_with_dashboard`.
+    pub async fn log_tag_metrics(log_state: LogWeak, recorder: Arc<MmRecorder>, interval: f64) {
+        loop {
+            Timer::sleep(interval).await;
+            let log_state = match LogArc::from_weak(&log_state) {
+                Some(log_arc) => log_arc,
+                _ => return,
+            };
+
+            log!(">>>>>>>>>> DEX metrics <<<<<<<<<");
+
+            Self::prepare_tag_metrics(&recorder)
+                .into_iter()
+                .for_each(|(labels, name_value_map)| {
+                    let tags = labels_to_tags(labels.iter());
+                    let message = name_value_map_to_message(&name_value_map);
+                    log_state.log_deref_tags("", tags, &message);
+                });
+        }
+    }
+
+    /// Prepare tag metrics for logging in `log_tag_metrics`.
+    fn prepare_tag_metrics(recorder: &MmRecorder) -> HashMap<MetricLabels, MetricNameValueMap> {
+        let mut output = HashMap::new();
+
+        for (key, counter) in recorder.registry.get_counter_handles() {
+            let value = counter.get_inner().load(Ordering::Acquire);
+            map_metrics_to_prepare_tag_metric_output(key, PreparedMetric::Unsigned(value), &mut output);
+        }
+
+        for (key, gauge) in recorder.registry.get_gauge_handles() {
+            let value = f64::from_bits(gauge.get_inner().load(Ordering::Acquire));
+            map_metrics_to_prepare_tag_metric_output(key, PreparedMetric::Float(value), &mut output);
+        }
+
+        for (key, histo) in recorder.registry.get_histogram_handles() {
+            if let Some(values) = MmHistogram::new(&histo.get_inner().data()) {
+                map_metrics_to_prepare_tag_metric_output(key, PreparedMetric::Histogram(values), &mut output);
+            }
+        }
+        output
+    }
+}
+
+/// Used for parsing metrics to `prepare_tag_metric_output`
+fn map_metrics_to_prepare_tag_metric_output(
+    key: Key,
+    value: PreparedMetric,
+    output: &mut HashMap<MetricLabels, MetricNameValueMap>,
+) {
+    let (metric_name, labels) = key.into_parts();
+    output
+        .entry(labels)
+        .or_insert_with(MetricNameValueMap::new)
+        .insert(metric_name.as_str().to_string(), value);
+}
+
+pub(crate) fn labels_to_tags(labels: Iter<Label>) -> Vec<Tag> {
+    labels
+        .map(|label| Tag {
+            key: label.key().to_string(),
+            val: Some(label.value().to_string()),
+        })
+        .collect()
+}
+
+/// Used for parsing `MetricNameValueMap` into Message(loggable string).
+pub(crate) fn name_value_map_to_message(name_value_map: &MetricNameValueMap) -> String {
+    name_value_map
+        .iter()
+        .sorted_by(|x, y| x.partial_cmp(y).unwrap_or(std::cmp::Ordering::Equal))
+        .map(|(key, value)| match value {
+            PreparedMetric::Unsigned(v) => format!("{}={:?}", key, v),
+            PreparedMetric::Float(v) => format!("{}={:?}", key, v),
+            PreparedMetric::Histogram(v) => format!("{}={:?}", key, v.to_tag_message()),
+        })
+        .join(" ")
+}
+
+#[derive(PartialEq, PartialOrd)]
+pub(crate) struct MmHistogram {
+    count: usize,
+    min: f64,
+    max: f64,
+}
+
+impl MmHistogram {
+    /// Create new MmHistogram from `&[f64]`.
+    ///
+    /// Return None if data.len() <= 0.
+    pub(crate) fn new(data: &[f64]) -> Option<MmHistogram> {
+        let (min, max) = data.iter().minmax().into_option()?;
+        Some(MmHistogram {
+            count: data.len(),
+            min: *min,
+            max: *max,
+        })
+    }
+
+    /// Create new MmHistogram from `&[f64]`.
+    pub(crate) fn to_tag_message(&self) -> String { format!("count={} min={} max={}", self.count, self.min, self.max) }
+
+    /// Create new MmHistogram from `&[f64]`.
+    pub(crate) fn to_json_quantiles(&self) -> HashMap<String, f64> {
+        let mut result = HashMap::new();
+        result.insert("count".to_owned(), self.count as f64);
+        result.insert("min".to_owned(), self.min);
+        result.insert("max".to_owned(), self.max);
+
+        result
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub mod prometheus {
+    use crate::{MetricsArc, MetricsWeak};
+
+    use super::*;
+    use futures::future::{Future, FutureExt};
+    use hyper::http::{self, header, Request, Response, StatusCode};
+    use hyper::service::{make_service_fn, service_fn};
+    use hyper::{Body, Server};
+    use mm2_err_handle::prelude::MmError;
+    use std::convert::Infallible;
+    use std::net::SocketAddr;
+
+    #[derive(Clone)]
+    pub struct PrometheusCredentials {
+        pub userpass: String,
+    }
+
+    pub fn spawn_prometheus_exporter(
+        metrics: MetricsWeak,
+        address: SocketAddr,
+        shutdown_detector: impl Future<Output = ()> + 'static + Send,
+        credentials: Option<PrometheusCredentials>,
+    ) -> Result<(), MmMetricsError> {
+        let make_svc = make_service_fn(move |_conn| {
+            let metrics = metrics.clone();
+            let credentials = credentials.clone();
+            futures::future::ready(Ok::<_, Infallible>(service_fn(move |req| {
+                futures::future::ready(scrape_handle(req, metrics.clone(), credentials.clone()))
+            })))
+        });
+
+        let server = Server::try_bind(&address)
+            .map_err(|e| MmMetricsError::PrometheusServerError(e.to_string()))?
+            .http1_half_close(false) // https://github.com/hyperium/hyper/issues/1764
+            .serve(make_svc)
+            .with_graceful_shutdown(shutdown_detector);
+
+        let server = server.then(|r| {
+            if let Err(err) = r {
+                error!("{}", err);
+            };
+            futures::future::ready(())
+        });
+
+        spawn(server);
+        Ok(())
+    }
+
+    fn scrape_handle(
+        req: Request<Body>,
+        metrics: MetricsWeak,
+        credentials: Option<PrometheusCredentials>,
+    ) -> Result<Response<Body>, http::Error> {
+        fn on_error(status: StatusCode, error: MmError<MmMetricsError>) -> Result<Response<Body>, http::Error> {
+            error!("{}", error);
+            Response::builder().status(status).body(Body::empty()).map_err(|err| {
+                error!("{}", err);
+                err
+            })
+        }
+
+        if req.uri() != "/metrics" {
+            return on_error(
+                StatusCode::BAD_REQUEST,
+                MmError::new(MmMetricsError::UnexpectedUri(req.uri().to_string())),
+            );
+        }
+
+        if let Some(credentials) = credentials {
+            if let Err(err) = check_auth_credentials(&req, credentials) {
+                return on_error(StatusCode::UNAUTHORIZED, err);
+            }
+        }
+
+        let metrics = match MetricsArc::from_weak(&metrics) {
+            Some(m) => m,
+            _ => {
+                return on_error(
+                    StatusCode::BAD_REQUEST,
+                    MmError::new(MmMetricsError::MetricsSystemUnavailable),
+                )
+            },
+        };
+
+        let body = Body::from(metrics.0.collect_prometheus_format());
+
+        Response::builder()
+            .status(StatusCode::OK)
+            .header(header::CONTENT_TYPE, "text/plain")
+            .body(body)
+            .map_err(|err| {
+                error!("{}", err);
+                err
+            })
+    }
+
+    fn check_auth_credentials(req: &Request<Body>, expected: PrometheusCredentials) -> MmMetricsResult<()> {
+        let header_value = req
+            .headers()
+            .get(header::AUTHORIZATION)
+            .ok_or(MmMetricsError::PrometheusAuthorizationRequired)
+            .and_then(|header| {
+                Ok(header
+                    .to_str()
+                    .map_err(|err| MmMetricsError::PrometheusServerError(err.to_string())))?
+            })?;
+
+        let expected = format!("Basic {}", base64::encode_config(&expected.userpass, base64::URL_SAFE));
+
+        if header_value != expected {
+            return Err(MmError::new(MmMetricsError::PrometheusInvalidCredentials(
+                header_value.to_string(),
+            )));
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use std::time::Duration;
+
+    use crate::{MetricsArc, MetricsOps};
+
+    use common::{block_on,
+                 executor::Timer,
+                 log::{LogArc, LogState}};
+    use wasm_timer::Instant;
+
+    #[test]
+    fn test_collect_json() {
+        let metrics = MetricsArc::new();
+
+        metrics.init();
+
+        mm_counter!(metrics, "rpc.traffic.tx", 62, "coin" => "BTC");
+        mm_counter!(metrics, "rpc.traffic.rx", 105, "coin" => "BTC");
+
+        mm_counter!(metrics, "rpc.traffic.tx", 30, "coin" => "BTC");
+        mm_counter!(metrics, "rpc.traffic.rx", 44, "coin" => "BTC");
+
+        mm_counter!(metrics, "rpc.traffic.tx", 54, "coin" => "KMD");
+        mm_counter!(metrics, "rpc.traffic.rx", 158, "coin" => "KMD");
+
+        mm_gauge!(metrics, "rpc.connection.count", 3.0, "coin" => "KMD");
+        mm_gauge!(metrics, "rpc.connection.count", 5.0, "coin" => "KMD");
+
+        let delta = Duration::from_secs(1);
+        mm_timing!(metrics,
+                   "rpc.query.spent_time",
+                   // ~ 1 second
+                   delta, // delta
+                   "coin" => "KMD",
+                   "method" => "blockchain.transaction.get");
+
+        let delta = Duration::from_secs(2);
+        mm_timing!(metrics,
+                   "rpc.query.spent_time",
+                   // ~ 2 second
+                    delta, // delta
+                   "coin" => "KMD",
+                   "method" => "blockchain.transaction.get");
+
+        let expected = serde_json::json!({
+            "metrics": [
+                {
+                    "key": "rpc.traffic.rx",
+                    "labels": { "coin": "BTC" },
+                    "type": "counter",
+                    "value": 149
+                },
+                {
+                    "key": "rpc.traffic.tx",
+                    "labels": { "coin": "KMD" },
+                    "type": "counter",
+                    "value": 54
+                },
+                {
+                    "key": "rpc.traffic.tx",
+                    "labels": { "coin": "BTC" },
+                    "type": "counter",
+                    "value": 92
+                },
+                {
+                    "key": "rpc.traffic.rx",
+                    "labels": { "coin": "KMD" },
+                    "type": "counter",
+                    "value": 158
+                },
+                {
+                    "count": 2.0,
+                    "key": "rpc.query.spent_time",
+                    "labels": { "coin": "KMD", "method": "blockchain.transaction.get" },
+                    "max": 2.0,
+                    "min": 1.0,
+                    "type": "histogram"
+                },
+                {
+                    "key": "rpc.connection.count",
+                    "labels": { "coin": "KMD" },
+                    "type": "gauge",
+                    "value": 5.0
+                }
+            ]
+        });
+
+        let mut actual = metrics.collect_json().unwrap();
+        let actual = actual["metrics"].as_array_mut().unwrap();
+        for expected in expected["metrics"].as_array().unwrap() {
+            let index = actual.iter().position(|metric| metric == expected).expect(&format!(
+                "Couldn't find expected metric: {:#?} \n in {:#?}",
+                expected, actual
+            ));
+            actual.remove(index);
+        }
+
+        assert!(
+            actual.is_empty(),
+            "More metrics collected than expected. Excess metrics: {:?}",
+            actual
+        );
+    }
+
+    #[test]
+    fn test_dashboard() {
+        let log_state = LogArc::new(LogState::in_memory());
+        let mm_metrics = MetricsArc::new();
+
+        mm_metrics.init_with_dashboard(log_state.weak(), 6.).unwrap();
+
+        let clock = Instant::now();
+        let last = clock.elapsed();
+
+        mm_counter!(mm_metrics, "rpc.traffic.tx", 62, "coin" => "BTC");
+        mm_counter!(mm_metrics, "rpc.traffic.rx", 105, "coin"=> "BTC");
+
+        mm_counter!(mm_metrics, "rpc.traffic.tx", 54, "coin" => "KMD");
+        mm_counter!(mm_metrics, "rpc.traffic.rx", 158, "coin" => "KMD");
+
+        mm_gauge!(mm_metrics, "rpc.connection.count", 3.0, "coin" => "KMD");
+
+        block_on(async { Timer::sleep(6.).await });
+
+        let delta: Duration = clock.elapsed() - last;
+        mm_timing!(mm_metrics,
+                    "rpc.query.spent_time",
+                    delta,
+                    "coin" => "KMD",
+                    "method" => "blockchain.transaction.get");
+
+        block_on(async { Timer::sleep(6.).await });
+
+        mm_counter!(mm_metrics, "rpc.traffic.tx", 30, "coin" => "BTC");
+        mm_counter!(mm_metrics, "rpc.traffic.rx", 44, "coin" => "BTC");
+
+        mm_gauge!(mm_metrics, "rpc.connection.count", 5.0, "coin" => "KMD");
+
+        let delta = clock.elapsed() - last;
+        mm_timing!(mm_metrics,
+                    "rpc.query.spent_time",
+                    delta,
+                    "coin" => "KMD",
+                    "method" => "blockchain.transaction.get");
+
+        // measure without labels
+        mm_counter!(mm_metrics, "test.counter", 0);
+        mm_gauge!(mm_metrics, "test.gauge", 1.0);
+        let delta: Duration = clock.elapsed() - last;
+        mm_timing!(mm_metrics, "test.uptime", delta);
+
+        block_on(async { Timer::sleep(6.).await });
+    }
+
+    #[test]
+    fn test_prometheus_format() {
+        let mm_metrics = MetricsArc::new();
+
+        mm_metrics.init();
+
+        mm_counter!(mm_metrics, "rpc.traffic.tx", 62, "coin" => "BTC");
+        mm_counter!(mm_metrics, "rpc.traffic.rx", 105, "coin" => "BTC");
+
+        mm_counter!(mm_metrics, "rpc.traffic.tx", 30, "coin" => "BTC");
+        mm_counter!(mm_metrics, "rpc.traffic.rx", 44, "coin" => "BTC");
+
+        mm_counter!(mm_metrics, "rpc.traffic.tx", 54, "coin" => "KMD");
+        mm_counter!(mm_metrics, "rpc.traffic.rx", 158, "coin" => "KMD");
+
+        mm_gauge!(mm_metrics, "rpc.connection.count", 3.0, "coin" => "KMD");
+        mm_gauge!(mm_metrics, "rpc.connection.count", 5.0, "coin" => "KMD");
+
+        mm_timing!(mm_metrics,
+                         "rpc.query.spent_time",
+                         4.5,
+                         "coin"=> "KMD",
+                         "method"=>"blockchain.transaction.get");
+
+        println!("{}", mm_metrics.0.collect_prometheus_format());
+    }
+}
diff --git a/mm2src/mm2_metrics/src/recorder.rs b/mm2src/mm2_metrics/src/recorder.rs
new file mode 100644
index 0000000000..a19ca982b8
--- /dev/null
+++ b/mm2src/mm2_metrics/src/recorder.rs
@@ -0,0 +1,195 @@
+use crate::{mm_metrics::MmHistogram, MetricType, MetricsJson};
+
+use metrics::{Counter, Gauge, Histogram, Key, KeyName, Label, Recorder, Unit};
+#[cfg(not(target_arch = "wasm32"))]
+use metrics_exporter_prometheus::formatting::{key_to_parts, write_metric_line, write_type_line};
+use metrics_util::registry::{GenerationalAtomicStorage, GenerationalStorage, Registry};
+use std::sync::{atomic::Ordering, Arc};
+use std::{collections::HashMap, slice::Iter};
+
+pub struct Snapshot {
+    pub counters: HashMap<String, HashMap<Vec<String>, u64>>,
+    pub gauges: HashMap<String, HashMap<Vec<String>, f64>>,
+    pub histograms: HashMap<String, HashMap<Vec<String>, Vec<f64>>>,
+}
+
+/// `MmRecorder` the core of mm metrics.
+///
+///  Registering, Recording, Updating and Collecting metrics is all done from within MmRecorder.
+pub struct MmRecorder {
+    pub(crate) registry: Registry<Key, GenerationalAtomicStorage>,
+}
+
+impl Default for MmRecorder {
+    fn default() -> Self {
+        Self {
+            registry: Registry::new(GenerationalStorage::atomic()),
+        }
+    }
+}
+
+impl MmRecorder {
+    #[cfg(not(target_arch = "wasm32"))]
+    fn get_metrics(&self) -> Snapshot {
+        let mut counters = HashMap::new();
+        for (key, counter) in self.registry.get_counter_handles() {
+            key_value_to_snapshot_entry(&mut counters, key, counter.get_inner().load(Ordering::Acquire));
+        }
+
+        let mut gauges = HashMap::new();
+        for (key, gauge) in self.registry.get_gauge_handles() {
+            key_value_to_snapshot_entry(
+                &mut gauges,
+                key,
+                f64::from_bits(gauge.get_inner().load(Ordering::Acquire)),
+            );
+        }
+
+        let mut histograms = HashMap::new();
+        for (key, histogram) in self.registry.get_histogram_handles() {
+            key_value_to_snapshot_entry(&mut histograms, key, histogram.get_inner().data());
+        }
+
+        Snapshot {
+            counters,
+            gauges,
+            histograms,
+        }
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn render_prometheus(&self) -> String {
+        let Snapshot {
+            mut counters,
+            mut histograms,
+            mut gauges,
+        } = self.get_metrics();
+
+        let mut output = String::new();
+
+        for (name, mut by_labels) in counters.drain() {
+            write_type_line(&mut output, name.as_str(), "counter");
+            for (labels, value) in by_labels.drain() {
+                write_metric_line::<&str, u64>(&mut output, &name, None, &labels, None, value);
+            }
+            output.push('\n');
+        }
+
+        for (name, mut by_labels) in gauges.drain() {
+            write_type_line(&mut output, name.as_str(), "gauge");
+            for (labels, value) in by_labels.drain() {
+                write_metric_line::<&str, f64>(&mut output, &name, None, &labels, None, value);
+            }
+            output.push('\n');
+        }
+
+        for (key, histogram) in histograms.drain() {
+            let key = Key::from_name(key.to_owned());
+            let (name, labels) = key_to_parts(&key, None);
+            write_type_line(&mut output, &name, "histogram");
+            for (_, values) in histogram {
+                let mut count = 0;
+                let mut sum = 0.0;
+
+                count += values.len();
+                values.iter().for_each(|value| {
+                    sum += value;
+                });
+
+                write_metric_line::<&str, f64>(&mut output, &name, Some("sum"), &labels, None, sum);
+                write_metric_line::<&str, usize>(
+                    &mut output,
+                    &name,
+                    Some("count"),
+                    key_to_parts(&key, None).1.as_slice(),
+                    None,
+                    count,
+                );
+                output.push('\n');
+            }
+        }
+
+        output
+    }
+
+    pub fn prepare_json(&self) -> MetricsJson {
+        let mut output = vec![];
+
+        for (key, counter) in self.registry.get_counter_handles() {
+            let (key, labels) = key.into_parts();
+            let value = counter.get_inner().load(Ordering::Acquire);
+            output.push(MetricType::Counter {
+                key: key.as_str().to_string(),
+                labels: labels_into_parts(labels.clone().iter()),
+                value,
+            });
+        }
+
+        for (key, gauge) in self.registry.get_gauge_handles() {
+            let (key, labels) = key.into_parts();
+            let value = f64::from_bits(gauge.get_inner().load(Ordering::Acquire));
+            output.push(MetricType::Gauge {
+                key: key.as_str().to_string(),
+                labels: labels_into_parts(labels.clone().iter()),
+                value,
+            });
+        }
+
+        for (key, histogram) in self.registry.get_histogram_handles() {
+            let value = histogram.get_inner().data();
+            let (key, labels) = key.into_parts();
+            let mm_histogram = MmHistogram::new(&value);
+
+            if let Some(qauntiles_value) = mm_histogram {
+                output.push(MetricType::Histogram {
+                    key: key.as_str().to_string(),
+                    labels: labels_into_parts(labels.clone().iter()),
+                    quantiles: qauntiles_value.to_json_quantiles(),
+                });
+            }
+        }
+
+        MetricsJson { metrics: output }
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+fn key_value_to_snapshot_entry<V>(metrics: &mut HashMap<String, HashMap<Vec<String>, V>>, key: Key, value: V) {
+    let (key_name, labels) = key_to_parts(&key, None);
+    let metrics = metrics.entry(key_name).or_insert_with(|| HashMap::new());
+    metrics.insert(labels, value);
+}
+
+impl Recorder for MmRecorder {
+    fn describe_counter(&self, _key_name: KeyName, _unit: Option<Unit>, _description: &'static str) {
+        // mm2_metrics doesn't use this method
+    }
+
+    fn describe_gauge(&self, _key_name: KeyName, _unit: Option<Unit>, _description: &'static str) {
+        // mm2_metrics doesn't use this method
+    }
+
+    fn describe_histogram(&self, _key_name: KeyName, _unit: Option<Unit>, _description: &'static str) {
+        // mm2_metrics doesn't use this method
+    }
+
+    fn register_counter(&self, key: &Key) -> Counter { self.registry.get_or_create_counter(key, |e| e.clone().into()) }
+
+    fn register_gauge(&self, key: &Key) -> Gauge { self.registry.get_or_create_gauge(key, |e| e.clone().into()) }
+
+    fn register_histogram(&self, key: &Key) -> Histogram {
+        self.registry.get_or_create_histogram(key, |e| e.clone().into())
+    }
+}
+
+pub trait TryRecorder {
+    /// Check for recorder and set one if none is set.
+    fn try_recorder(&self) -> Option<Arc<MmRecorder>>;
+}
+
+/// Used for parsing `Iter<Label>` into `Key` and `Value`.
+fn labels_into_parts(labels: Iter<Label>) -> HashMap<String, String> {
+    labels
+        .map(|label| (label.key().to_string(), label.value().to_string()))
+        .collect()
+}
diff --git a/mm2src/mm2_test_helpers/Cargo.toml b/mm2src/mm2_test_helpers/Cargo.toml
index 23a355e305..6a930d4ab9 100644
--- a/mm2src/mm2_test_helpers/Cargo.toml
+++ b/mm2src/mm2_test_helpers/Cargo.toml
@@ -15,6 +15,7 @@ http = "0.2"
 lazy_static = "1.4"
 mm2_core = { path = "../mm2_core" }
 mm2_io = { path = "../mm2_io" }
+mm2_metrics = { path = "../mm2_metrics" }
 mm2_net = { path = "../mm2_net" }
 mm2_number = { path = "../mm2_number" }
 rand = { version = "0.7", features = ["std", "small_rng", "wasm-bindgen"] }
diff --git a/mm2src/mm2_test_helpers/src/for_tests.rs b/mm2src/mm2_test_helpers/src/for_tests.rs
index 9a7751d666..74385e31f7 100644
--- a/mm2src/mm2_test_helpers/src/for_tests.rs
+++ b/mm2src/mm2_test_helpers/src/for_tests.rs
@@ -16,9 +16,9 @@ use uuid::Uuid;
 
 use common::executor::Timer;
 use common::log;
-use common::mm_metrics::{MetricType, MetricsJson};
 use common::{cfg_native, now_float, now_ms, PagingOptionsEnum};
 use mm2_core::mm_ctx::{MmArc, MmCtxBuilder};
+use mm2_metrics::{MetricType, MetricsJson};
 
 cfg_native! {
     use common::block_on;