Revert "metrics have been added"

This reverts commit 16e792be75335b09a4f9f254e3972030af83b1ad, reversing
changes made to 3790f3d771d1a65ed6c0d05f3e0d79ff13308142.

16 files changed, 0 insertions, 1563 deletions

diff --git a/library/go/core/metrics/prometheus/counter.go b/library/go/core/metrics/prometheus/counter.go
deleted file mode 100644
index 1a07063f30..0000000000
--- a/library/go/core/metrics/prometheus/counter.go
+++ /dev/null
@@ -1,34 +0,0 @@
-package prometheus
-
-import (
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/ydb-platform/ydb/library/go/core/metrics"
-)
-
-var _ metrics.Counter = (*Counter)(nil)
-
-// Counter tracks monotonically increasing value.
-type Counter struct {
-	cnt prometheus.Counter
-}
-
-// Inc increments counter by 1.
-func (c Counter) Inc() {
-	c.cnt.Inc()
-}
-
-// Add adds delta to the counter. Delta must be >=0.
-func (c Counter) Add(delta int64) {
-	c.cnt.Add(float64(delta))
-}
-
-var _ metrics.FuncCounter = (*FuncCounter)(nil)
-
-type FuncCounter struct {
-	cnt      prometheus.CounterFunc
-	function func() int64
-}
-
-func (c FuncCounter) Function() func() int64 {
-	return c.function
-}
diff --git a/library/go/core/metrics/prometheus/counter_test.go b/library/go/core/metrics/prometheus/counter_test.go
deleted file mode 100644
index 04f0c894f8..0000000000
--- a/library/go/core/metrics/prometheus/counter_test.go
+++ /dev/null
@@ -1,38 +0,0 @@
-package prometheus
-
-import (
-	"testing"
-
-	"github.com/prometheus/client_golang/prometheus"
-	dto "github.com/prometheus/client_model/go"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestCounter_Add(t *testing.T) {
-	c := &Counter{cnt: prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "test_counter_add",
-	})}
-
-	var expectValue int64 = 42
-	c.Add(expectValue)
-
-	var res dto.Metric
-	err := c.cnt.Write(&res)
-
-	assert.NoError(t, err)
-	assert.Equal(t, expectValue, int64(res.GetCounter().GetValue()))
-}
-
-func TestCounter_Inc(t *testing.T) {
-	c := &Counter{cnt: prometheus.NewCounter(prometheus.CounterOpts{
-		Name: "test_counter_inc",
-	})}
-
-	var res dto.Metric
-	for i := 1; i <= 10; i++ {
-		c.Inc()
-		err := c.cnt.Write(&res)
-		assert.NoError(t, err)
-		assert.Equal(t, int64(i), int64(res.GetCounter().GetValue()))
-	}
-}
diff --git a/library/go/core/metrics/prometheus/gauge.go b/library/go/core/metrics/prometheus/gauge.go
deleted file mode 100644
index 8683755561..0000000000
--- a/library/go/core/metrics/prometheus/gauge.go
+++ /dev/null
@@ -1,32 +0,0 @@
-package prometheus
-
-import (
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/ydb-platform/ydb/library/go/core/metrics"
-)
-
-var _ metrics.Gauge = (*Gauge)(nil)
-
-// Gauge tracks single float64 value.
-type Gauge struct {
-	gg prometheus.Gauge
-}
-
-func (g Gauge) Set(value float64) {
-	g.gg.Set(value)
-}
-
-func (g Gauge) Add(value float64) {
-	g.gg.Add(value)
-}
-
-var _ metrics.FuncGauge = (*FuncGauge)(nil)
-
-type FuncGauge struct {
-	ff       prometheus.GaugeFunc
-	function func() float64
-}
-
-func (g FuncGauge) Function() func() float64 {
-	return g.function
-}
diff --git a/library/go/core/metrics/prometheus/gauge_test.go b/library/go/core/metrics/prometheus/gauge_test.go
deleted file mode 100644
index aebb7586c1..0000000000
--- a/library/go/core/metrics/prometheus/gauge_test.go
+++ /dev/null
@@ -1,39 +0,0 @@
-package prometheus
-
-import (
-	"testing"
-
-	"github.com/prometheus/client_golang/prometheus"
-	dto "github.com/prometheus/client_model/go"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestGauge_Add(t *testing.T) {
-	g := &Gauge{gg: prometheus.NewGauge(prometheus.GaugeOpts{
-		Name: "test_gauge_add",
-	})}
-
-	var expectValue float64 = 42
-	g.Add(expectValue)
-
-	var res dto.Metric
-	err := g.gg.Write(&res)
-
-	assert.NoError(t, err)
-	assert.Equal(t, expectValue, res.GetGauge().GetValue())
-}
-
-func TestGauge_Set(t *testing.T) {
-	g := &Gauge{gg: prometheus.NewGauge(prometheus.GaugeOpts{
-		Name: "test_gauge_set",
-	})}
-
-	var expectValue float64 = 42
-	g.Set(expectValue)
-
-	var res dto.Metric
-	err := g.gg.Write(&res)
-
-	assert.NoError(t, err)
-	assert.Equal(t, expectValue, res.GetGauge().GetValue())
-}
diff --git a/library/go/core/metrics/prometheus/gotest/ya.make b/library/go/core/metrics/prometheus/gotest/ya.make
deleted file mode 100644
index 466256dcaa..0000000000
--- a/library/go/core/metrics/prometheus/gotest/ya.make
+++ /dev/null
@@ -1,3 +0,0 @@
-GO_TEST_FOR(library/go/core/metrics/prometheus)
-
-END()
diff --git a/library/go/core/metrics/prometheus/histogram.go b/library/go/core/metrics/prometheus/histogram.go
deleted file mode 100644
index bd5e0dca66..0000000000
--- a/library/go/core/metrics/prometheus/histogram.go
+++ /dev/null
@@ -1,22 +0,0 @@
-package prometheus
-
-import (
-	"time"
-
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/ydb-platform/ydb/library/go/core/metrics"
-)
-
-var _ metrics.Histogram = (*Histogram)(nil)
-
-type Histogram struct {
-	hm prometheus.Observer
-}
-
-func (h Histogram) RecordValue(value float64) {
-	h.hm.Observe(value)
-}
-
-func (h Histogram) RecordDuration(value time.Duration) {
-	h.hm.Observe(value.Seconds())
-}
diff --git a/library/go/core/metrics/prometheus/histogram_test.go b/library/go/core/metrics/prometheus/histogram_test.go
deleted file mode 100644
index 0dec46589c..0000000000
--- a/library/go/core/metrics/prometheus/histogram_test.go
+++ /dev/null
@@ -1,91 +0,0 @@
-package prometheus
-
-import (
-	"testing"
-	"time"
-
-	"github.com/google/go-cmp/cmp"
-	"github.com/google/go-cmp/cmp/cmpopts"
-	dto "github.com/prometheus/client_model/go"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/ydb-platform/ydb/library/go/core/metrics"
-	"github.com/ydb-platform/ydb/library/go/ptr"
-	"google.golang.org/protobuf/testing/protocmp"
-)
-
-func TestHistogram_RecordValue(t *testing.T) {
-	rg := NewRegistry(NewRegistryOpts())
-
-	h := rg.Histogram("test_histogram_record_value",
-		metrics.NewBuckets(0.1, 1.0, 15.47, 42.0, 128.256),
-	)
-
-	for _, value := range []float64{0.5, 0.7, 34.1234, 127} {
-		h.RecordValue(value)
-	}
-
-	expectBuckets := []*dto.Bucket{
-		{CumulativeCount: ptr.Uint64(0), UpperBound: ptr.Float64(0.1)},
-		{CumulativeCount: ptr.Uint64(2), UpperBound: ptr.Float64(1.0)},
-		{CumulativeCount: ptr.Uint64(2), UpperBound: ptr.Float64(15.47)},
-		{CumulativeCount: ptr.Uint64(3), UpperBound: ptr.Float64(42.0)},
-		{CumulativeCount: ptr.Uint64(4), UpperBound: ptr.Float64(128.256)},
-	}
-
-	gathered, err := rg.Gather()
-	require.NoError(t, err)
-
-	resBuckets := gathered[0].Metric[0].GetHistogram().GetBucket()
-
-	cmpOpts := []cmp.Option{
-		cmpopts.IgnoreUnexported(),
-		protocmp.Transform(),
-	}
-	assert.True(t, cmp.Equal(expectBuckets, resBuckets, cmpOpts...), cmp.Diff(expectBuckets, resBuckets, cmpOpts...))
-}
-
-func TestDurationHistogram_RecordDuration(t *testing.T) {
-	rg := NewRegistry(NewRegistryOpts())
-
-	ht := rg.DurationHistogram("test_histogram_record_value",
-		metrics.NewDurationBuckets(
-			1*time.Millisecond,                   // 0.1
-			1*time.Second,                        // 1.0
-			15*time.Second+470*time.Millisecond,  // 15.47
-			42*time.Second,                       // 42.0
-			128*time.Second+256*time.Millisecond, // 128.256
-		),
-	)
-
-	values := []time.Duration{
-		500 * time.Millisecond,
-		700 * time.Millisecond,
-		34*time.Second + 1234*time.Millisecond,
-		127 * time.Second,
-	}
-
-	for _, value := range values {
-		ht.RecordDuration(value)
-	}
-
-	expectBuckets := []*dto.Bucket{
-		{CumulativeCount: ptr.Uint64(0), UpperBound: ptr.Float64(0.001)},
-		{CumulativeCount: ptr.Uint64(2), UpperBound: ptr.Float64(1)},
-		{CumulativeCount: ptr.Uint64(2), UpperBound: ptr.Float64(15.47)},
-		{CumulativeCount: ptr.Uint64(3), UpperBound: ptr.Float64(42)},
-		{CumulativeCount: ptr.Uint64(4), UpperBound: ptr.Float64(128.256)},
-	}
-
-	gathered, err := rg.Gather()
-	require.NoError(t, err)
-
-	resBuckets := gathered[0].Metric[0].GetHistogram().GetBucket()
-
-	cmpOpts := []cmp.Option{
-		cmpopts.IgnoreUnexported(),
-		protocmp.Transform(),
-	}
-
-	assert.True(t, cmp.Equal(expectBuckets, resBuckets, cmpOpts...), cmp.Diff(expectBuckets, resBuckets, cmpOpts...))
-}
diff --git a/library/go/core/metrics/prometheus/int_gauge.go b/library/go/core/metrics/prometheus/int_gauge.go
deleted file mode 100644
index 813b87828c..0000000000
--- a/library/go/core/metrics/prometheus/int_gauge.go
+++ /dev/null
@@ -1,32 +0,0 @@
-package prometheus
-
-import (
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/ydb-platform/ydb/library/go/core/metrics"
-)
-
-var _ metrics.IntGauge = (*IntGauge)(nil)
-
-// IntGauge tracks single int64 value.
-type IntGauge struct {
-	metrics.Gauge
-}
-
-func (i IntGauge) Set(value int64) {
-	i.Gauge.Set(float64(value))
-}
-
-func (i IntGauge) Add(value int64) {
-	i.Gauge.Add(float64(value))
-}
-
-var _ metrics.FuncIntGauge = (*FuncIntGauge)(nil)
-
-type FuncIntGauge struct {
-	ff       prometheus.GaugeFunc
-	function func() int64
-}
-
-func (g FuncIntGauge) Function() func() int64 {
-	return g.function
-}
diff --git a/library/go/core/metrics/prometheus/registry.go b/library/go/core/metrics/prometheus/registry.go
deleted file mode 100644
index bad45fe617..0000000000
--- a/library/go/core/metrics/prometheus/registry.go
+++ /dev/null
@@ -1,254 +0,0 @@
-package prometheus
-
-import (
-	"sync"
-
-	"github.com/prometheus/client_golang/prometheus"
-	dto "github.com/prometheus/client_model/go"
-	"github.com/ydb-platform/ydb/library/go/core/metrics"
-	"github.com/ydb-platform/ydb/library/go/core/metrics/internal/pkg/metricsutil"
-	"github.com/ydb-platform/ydb/library/go/core/metrics/internal/pkg/registryutil"
-	"github.com/ydb-platform/ydb/library/go/core/xerrors"
-)
-
-var _ metrics.Registry = (*Registry)(nil)
-
-type Registry struct {
-	rg *prometheus.Registry
-
-	m             *sync.Mutex
-	subregistries map[string]*Registry
-
-	tags          map[string]string
-	prefix        string
-	nameSanitizer func(string) string
-}
-
-// NewRegistry creates new Prometheus backed registry.
-func NewRegistry(opts *RegistryOpts) *Registry {
-	r := &Registry{
-		rg:            prometheus.NewRegistry(),
-		m:             new(sync.Mutex),
-		subregistries: make(map[string]*Registry),
-		tags:          make(map[string]string),
-	}
-
-	if opts != nil {
-		r.prefix = opts.Prefix
-		r.tags = opts.Tags
-		if opts.rg != nil {
-			r.rg = opts.rg
-		}
-		for _, collector := range opts.Collectors {
-			collector(r)
-		}
-		if opts.NameSanitizer != nil {
-			r.nameSanitizer = opts.NameSanitizer
-		}
-	}
-
-	return r
-}
-
-// WithTags creates new sub-scope, where each metric has tags attached to it.
-func (r Registry) WithTags(tags map[string]string) metrics.Registry {
-	return r.newSubregistry(r.prefix, registryutil.MergeTags(r.tags, tags))
-}
-
-// WithPrefix creates new sub-scope, where each metric has prefix added to it name.
-func (r Registry) WithPrefix(prefix string) metrics.Registry {
-	return r.newSubregistry(registryutil.BuildFQName("_", r.prefix, prefix), r.tags)
-}
-
-// ComposeName builds FQ name with appropriate separator.
-func (r Registry) ComposeName(parts ...string) string {
-	return registryutil.BuildFQName("_", parts...)
-}
-
-func (r Registry) Counter(name string) metrics.Counter {
-	name = r.sanitizeName(name)
-	cnt := prometheus.NewCounter(prometheus.CounterOpts{
-		Namespace:   r.prefix,
-		Name:        name,
-		ConstLabels: r.tags,
-	})
-
-	if err := r.rg.Register(cnt); err != nil {
-		var existErr prometheus.AlreadyRegisteredError
-		if xerrors.As(err, &existErr) {
-			return &Counter{cnt: existErr.ExistingCollector.(prometheus.Counter)}
-		}
-		panic(err)
-	}
-
-	return &Counter{cnt: cnt}
-}
-
-func (r Registry) FuncCounter(name string, function func() int64) metrics.FuncCounter {
-	name = r.sanitizeName(name)
-	cnt := prometheus.NewCounterFunc(prometheus.CounterOpts{
-		Namespace:   r.prefix,
-		Name:        name,
-		ConstLabels: r.tags,
-	}, func() float64 {
-		return float64(function())
-	})
-
-	if err := r.rg.Register(cnt); err != nil {
-		panic(err)
-	}
-
-	return &FuncCounter{
-		cnt:      cnt,
-		function: function,
-	}
-}
-
-func (r Registry) Gauge(name string) metrics.Gauge {
-	name = r.sanitizeName(name)
-	gg := prometheus.NewGauge(prometheus.GaugeOpts{
-		Namespace:   r.prefix,
-		Name:        name,
-		ConstLabels: r.tags,
-	})
-
-	if err := r.rg.Register(gg); err != nil {
-		var existErr prometheus.AlreadyRegisteredError
-		if xerrors.As(err, &existErr) {
-			return &Gauge{gg: existErr.ExistingCollector.(prometheus.Gauge)}
-		}
-		panic(err)
-	}
-
-	return &Gauge{gg: gg}
-}
-
-func (r Registry) FuncGauge(name string, function func() float64) metrics.FuncGauge {
-	name = r.sanitizeName(name)
-	ff := prometheus.NewGaugeFunc(prometheus.GaugeOpts{
-		Namespace:   r.prefix,
-		Name:        name,
-		ConstLabels: r.tags,
-	}, function)
-	if err := r.rg.Register(ff); err != nil {
-		panic(err)
-	}
-	return &FuncGauge{
-		ff:       ff,
-		function: function,
-	}
-}
-
-func (r Registry) IntGauge(name string) metrics.IntGauge {
-	return &IntGauge{Gauge: r.Gauge(name)}
-}
-
-func (r Registry) FuncIntGauge(name string, function func() int64) metrics.FuncIntGauge {
-	name = r.sanitizeName(name)
-	ff := prometheus.NewGaugeFunc(prometheus.GaugeOpts{
-		Namespace:   r.prefix,
-		Name:        name,
-		ConstLabels: r.tags,
-	}, func() float64 { return float64(function()) })
-	if err := r.rg.Register(ff); err != nil {
-		panic(err)
-	}
-	return &FuncIntGauge{
-		ff:       ff,
-		function: function,
-	}
-}
-
-func (r Registry) Timer(name string) metrics.Timer {
-	name = r.sanitizeName(name)
-	gg := prometheus.NewGauge(prometheus.GaugeOpts{
-		Namespace:   r.prefix,
-		Name:        name,
-		ConstLabels: r.tags,
-	})
-
-	if err := r.rg.Register(gg); err != nil {
-		var existErr prometheus.AlreadyRegisteredError
-		if xerrors.As(err, &existErr) {
-			return &Timer{gg: existErr.ExistingCollector.(prometheus.Gauge)}
-		}
-		panic(err)
-	}
-
-	return &Timer{gg: gg}
-}
-
-func (r Registry) Histogram(name string, buckets metrics.Buckets) metrics.Histogram {
-	name = r.sanitizeName(name)
-	hm := prometheus.NewHistogram(prometheus.HistogramOpts{
-		Namespace:   r.prefix,
-		Name:        name,
-		ConstLabels: r.tags,
-		Buckets:     metricsutil.BucketsBounds(buckets),
-	})
-
-	if err := r.rg.Register(hm); err != nil {
-		var existErr prometheus.AlreadyRegisteredError
-		if xerrors.As(err, &existErr) {
-			return &Histogram{hm: existErr.ExistingCollector.(prometheus.Observer)}
-		}
-		panic(err)
-	}
-
-	return &Histogram{hm: hm}
-}
-
-func (r Registry) DurationHistogram(name string, buckets metrics.DurationBuckets) metrics.Timer {
-	name = r.sanitizeName(name)
-	hm := prometheus.NewHistogram(prometheus.HistogramOpts{
-		Namespace:   r.prefix,
-		Name:        name,
-		ConstLabels: r.tags,
-		Buckets:     metricsutil.DurationBucketsBounds(buckets),
-	})
-
-	if err := r.rg.Register(hm); err != nil {
-		var existErr prometheus.AlreadyRegisteredError
-		if xerrors.As(err, &existErr) {
-			return &Histogram{hm: existErr.ExistingCollector.(prometheus.Histogram)}
-		}
-		panic(err)
-	}
-
-	return &Histogram{hm: hm}
-}
-
-// Gather returns raw collected Prometheus metrics.
-func (r Registry) Gather() ([]*dto.MetricFamily, error) {
-	return r.rg.Gather()
-}
-
-func (r *Registry) newSubregistry(prefix string, tags map[string]string) *Registry {
-	registryKey := registryutil.BuildRegistryKey(prefix, tags)
-
-	r.m.Lock()
-	defer r.m.Unlock()
-
-	if old, ok := r.subregistries[registryKey]; ok {
-		return old
-	}
-
-	subregistry := &Registry{
-		rg:            r.rg,
-		m:             r.m,
-		subregistries: r.subregistries,
-		tags:          tags,
-		prefix:        prefix,
-		nameSanitizer: r.nameSanitizer,
-	}
-
-	r.subregistries[registryKey] = subregistry
-	return subregistry
-}
-
-func (r *Registry) sanitizeName(name string) string {
-	if r.nameSanitizer == nil {
-		return name
-	}
-	return r.nameSanitizer(name)
-}
diff --git a/library/go/core/metrics/prometheus/registry_opts.go b/library/go/core/metrics/prometheus/registry_opts.go
deleted file mode 100644
index fedb019d85..0000000000
--- a/library/go/core/metrics/prometheus/registry_opts.go
+++ /dev/null
@@ -1,84 +0,0 @@
-package prometheus
-
-import (
-	"context"
-
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/ydb-platform/ydb/library/go/core/metrics"
-	"github.com/ydb-platform/ydb/library/go/core/metrics/collect"
-	"github.com/ydb-platform/ydb/library/go/core/metrics/internal/pkg/registryutil"
-)
-
-type RegistryOpts struct {
-	Prefix        string
-	Tags          map[string]string
-	rg            *prometheus.Registry
-	Collectors    []func(metrics.Registry)
-	NameSanitizer func(string) string
-}
-
-// NewRegistryOpts returns new initialized instance of RegistryOpts.
-func NewRegistryOpts() *RegistryOpts {
-	return &RegistryOpts{
-		Tags: make(map[string]string),
-	}
-}
-
-// SetTags overrides existing tags.
-func (o *RegistryOpts) SetTags(tags map[string]string) *RegistryOpts {
-	o.Tags = tags
-	return o
-}
-
-// AddTags merges given tags with existing.
-func (o *RegistryOpts) AddTags(tags map[string]string) *RegistryOpts {
-	for k, v := range tags {
-		o.Tags[k] = v
-	}
-	return o
-}
-
-// SetPrefix overrides existing prefix.
-func (o *RegistryOpts) SetPrefix(prefix string) *RegistryOpts {
-	o.Prefix = prefix
-	return o
-}
-
-// AppendPrefix adds given prefix as postfix to existing using separator.
-func (o *RegistryOpts) AppendPrefix(prefix string) *RegistryOpts {
-	o.Prefix = registryutil.BuildFQName("_", o.Prefix, prefix)
-	return o
-}
-
-// SetRegistry sets the given prometheus registry for further usage instead
-// of creating a new one.
-//
-// This is primarily used to unite externally defined metrics with metrics kept
-// in the core registry.
-func (o *RegistryOpts) SetRegistry(rg *prometheus.Registry) *RegistryOpts {
-	o.rg = rg
-	return o
-}
-
-// AddCollectors adds collectors that handle their metrics automatically (e.g. system metrics).
-func (o *RegistryOpts) AddCollectors(
-	ctx context.Context, c metrics.CollectPolicy, collectors ...collect.Func,
-) *RegistryOpts {
-	if len(collectors) == 0 {
-		return o
-	}
-
-	o.Collectors = append(o.Collectors, func(r metrics.Registry) {
-		for _, collector := range collectors {
-			collector(ctx, r, c)
-		}
-	})
-	return o
-}
-
-// SetNameSanitizer sets a functions which will be called for each metric's name.
-// It allows to alter names, for example to replace invalid characters
-func (o *RegistryOpts) SetNameSanitizer(v func(string) string) *RegistryOpts {
-	o.NameSanitizer = v
-	return o
-}
diff --git a/library/go/core/metrics/prometheus/registry_test.go b/library/go/core/metrics/prometheus/registry_test.go
deleted file mode 100644
index 73d071a8de..0000000000
--- a/library/go/core/metrics/prometheus/registry_test.go
+++ /dev/null
@@ -1,481 +0,0 @@
-package prometheus
-
-import (
-	"strings"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/google/go-cmp/cmp"
-	"github.com/prometheus/client_golang/prometheus"
-	dto "github.com/prometheus/client_model/go"
-	"github.com/stretchr/testify/assert"
-	"github.com/ydb-platform/ydb/library/go/core/metrics"
-	"github.com/ydb-platform/ydb/library/go/ptr"
-	"github.com/ydb-platform/ydb/library/go/test/assertpb"
-	"google.golang.org/protobuf/testing/protocmp"
-)
-
-func TestNewRegistry(t *testing.T) {
-	expected := &Registry{
-		rg:            prometheus.NewRegistry(),
-		m:             new(sync.Mutex),
-		subregistries: make(map[string]*Registry),
-		tags:          map[string]string{},
-		prefix:        "",
-	}
-
-	r := NewRegistry(nil)
-	assert.IsType(t, expected, r)
-	assert.Equal(t, expected, r)
-}
-
-func TestRegistry_Subregisters(t *testing.T) {
-	r := NewRegistry(nil)
-	sr1 := r.WithPrefix("subregister1").
-		WithTags(map[string]string{"ololo": "trololo"})
-	sr2 := sr1.WithPrefix("subregister2").
-		WithTags(map[string]string{"shimba": "boomba"})
-
-	// check global subregistries map
-	expectedMap := map[string]*Registry{
-		"\"subregister1\"{}": {
-			rg:            r.rg,
-			m:             r.m,
-			subregistries: r.subregistries,
-			prefix:        "subregister1",
-			tags:          make(map[string]string),
-		},
-		"\"subregister1\"{ololo=trololo}": {
-			rg:            r.rg,
-			m:             r.m,
-			subregistries: r.subregistries,
-			tags:          map[string]string{"ololo": "trololo"},
-			prefix:        "subregister1",
-		},
-		"\"subregister1_subregister2\"{ololo=trololo}": {
-			rg:            r.rg,
-			m:             r.m,
-			subregistries: r.subregistries,
-			tags:          map[string]string{"ololo": "trololo"},
-			prefix:        "subregister1_subregister2",
-		},
-		"\"subregister1_subregister2\"{ololo=trololo,shimba=boomba}": {
-			rg:            r.rg,
-			m:             r.m,
-			subregistries: r.subregistries,
-			tags:          map[string]string{"ololo": "trololo", "shimba": "boomba"},
-			prefix:        "subregister1_subregister2",
-		},
-	}
-
-	assert.EqualValues(t, expectedMap, r.subregistries)
-
-	// top-register write
-	rCnt := r.Counter("subregisters_count")
-	rCnt.Add(2)
-
-	// sub-register write
-	srTm := sr1.Timer("mytimer")
-	srTm.RecordDuration(42 * time.Second)
-
-	// sub-sub-register write
-	srHm := sr2.Histogram("myhistogram", metrics.NewBuckets(1, 2, 3))
-	srHm.RecordValue(1.5)
-
-	mr, err := r.Gather()
-	assert.NoError(t, err)
-
-	assert.IsType(t, mr, []*dto.MetricFamily{})
-
-	expected := []*dto.MetricFamily{
-		{
-			Name: ptr.String("subregister1_mytimer"),
-			Help: ptr.String(""),
-			Type: func(mt dto.MetricType) *dto.MetricType { return &mt }(dto.MetricType_GAUGE),
-			Metric: []*dto.Metric{
-				{
-					Label: []*dto.LabelPair{
-						{Name: ptr.String("ololo"), Value: ptr.String("trololo")},
-					},
-					Gauge: &dto.Gauge{Value: ptr.Float64(42)},
-				},
-			},
-		},
-		{
-			Name: ptr.String("subregister1_subregister2_myhistogram"),
-			Help: ptr.String(""),
-			Type: func(mt dto.MetricType) *dto.MetricType { return &mt }(dto.MetricType_HISTOGRAM),
-			Metric: []*dto.Metric{
-				{
-					Label: []*dto.LabelPair{
-						{Name: ptr.String("ololo"), Value: ptr.String("trololo")},
-						{Name: ptr.String("shimba"), Value: ptr.String("boomba")},
-					},
-					Histogram: &dto.Histogram{
-						SampleCount: ptr.Uint64(1),
-						SampleSum:   ptr.Float64(1.5),
-						Bucket: []*dto.Bucket{
-							{CumulativeCount: ptr.Uint64(0), UpperBound: ptr.Float64(1)},
-							{CumulativeCount: ptr.Uint64(1), UpperBound: ptr.Float64(2)},
-							{CumulativeCount: ptr.Uint64(1), UpperBound: ptr.Float64(3)},
-						},
-					},
-				},
-			},
-		},
-		{
-			Name: ptr.String("subregisters_count"),
-			Help: ptr.String(""),
-			Type: func(mt dto.MetricType) *dto.MetricType { return &mt }(dto.MetricType_COUNTER),
-			Metric: []*dto.Metric{
-				{
-					Label:   []*dto.LabelPair{},
-					Counter: &dto.Counter{Value: ptr.Float64(2)},
-				},
-			},
-		},
-	}
-
-	cmpOpts := []cmp.Option{
-		protocmp.Transform(),
-	}
-	assert.True(t, cmp.Equal(expected, mr, cmpOpts...), cmp.Diff(expected, mr, cmpOpts...))
-}
-
-func TestRegistry_Counter(t *testing.T) {
-	r := NewRegistry(nil)
-	sr := r.WithPrefix("myprefix").
-		WithTags(map[string]string{"ololo": "trololo"})
-
-	// must panic on empty name
-	assert.Panics(t, func() { r.Counter("") })
-
-	srCnt := sr.Counter("mycounter")
-	srCnt.Add(42)
-
-	mr, err := r.Gather()
-	assert.NoError(t, err)
-
-	assert.IsType(t, mr, []*dto.MetricFamily{})
-
-	expected := []*dto.MetricFamily{
-		{
-			Name: ptr.String("myprefix_mycounter"),
-			Help: ptr.String(""),
-			Type: func(mt dto.MetricType) *dto.MetricType { return &mt }(dto.MetricType_COUNTER),
-			Metric: []*dto.Metric{
-				{
-					Label: []*dto.LabelPair{
-						{Name: ptr.String("ololo"), Value: ptr.String("trololo")},
-					},
-					Counter: &dto.Counter{Value: ptr.Float64(42)},
-				},
-			},
-		},
-	}
-	cmpOpts := []cmp.Option{
-		protocmp.Transform(),
-	}
-	assert.True(t, cmp.Equal(expected, mr, cmpOpts...), cmp.Diff(expected, mr, cmpOpts...))
-}
-
-func TestRegistry_DurationHistogram(t *testing.T) {
-	r := NewRegistry(nil)
-	sr := r.WithPrefix("myprefix").
-		WithTags(map[string]string{"ololo": "trololo"})
-
-	// must panic on empty name
-	assert.Panics(t, func() { r.DurationHistogram("", nil) })
-
-	cnt := sr.DurationHistogram("myhistogram", metrics.NewDurationBuckets(
-		1*time.Second, 3*time.Second, 5*time.Second,
-	))
-
-	cnt.RecordDuration(2 * time.Second)
-	cnt.RecordDuration(4 * time.Second)
-
-	mr, err := r.Gather()
-	assert.NoError(t, err)
-
-	assert.IsType(t, mr, []*dto.MetricFamily{})
-
-	expected := []*dto.MetricFamily{
-		{
-			Name: ptr.String("myprefix_myhistogram"),
-			Help: ptr.String(""),
-			Type: func(mt dto.MetricType) *dto.MetricType { return &mt }(dto.MetricType_HISTOGRAM),
-			Metric: []*dto.Metric{
-				{
-					Label: []*dto.LabelPair{{Name: ptr.String("ololo"), Value: ptr.String("trololo")}},
-					Histogram: &dto.Histogram{
-						SampleCount: ptr.Uint64(2),
-						SampleSum:   ptr.Float64(6),
-						Bucket: []*dto.Bucket{
-							{CumulativeCount: ptr.Uint64(0), UpperBound: ptr.Float64(1)},
-							{CumulativeCount: ptr.Uint64(1), UpperBound: ptr.Float64(3)},
-							{CumulativeCount: ptr.Uint64(2), UpperBound: ptr.Float64(5)},
-						},
-					},
-				},
-			},
-		},
-	}
-	assertpb.Equal(t, expected, mr)
-}
-
-func TestRegistry_Gauge(t *testing.T) {
-	r := NewRegistry(nil)
-	sr := r.WithPrefix("myprefix").
-		WithTags(map[string]string{"ololo": "trololo"})
-
-	// must panic on empty name
-	assert.Panics(t, func() { r.Gauge("") })
-
-	cnt := sr.Gauge("mygauge")
-	cnt.Add(42)
-
-	mr, err := r.Gather()
-	assert.NoError(t, err)
-
-	assert.IsType(t, mr, []*dto.MetricFamily{})
-
-	expected := []*dto.MetricFamily{
-		{
-			Name: ptr.String("myprefix_mygauge"),
-			Help: ptr.String(""),
-			Type: func(mt dto.MetricType) *dto.MetricType { return &mt }(dto.MetricType_GAUGE),
-			Metric: []*dto.Metric{
-				{
-					Label: []*dto.LabelPair{{Name: ptr.String("ololo"), Value: ptr.String("trololo")}},
-					Gauge: &dto.Gauge{Value: ptr.Float64(42)},
-				},
-			},
-		},
-	}
-	assertpb.Equal(t, expected, mr)
-}
-
-func TestRegistry_Histogram(t *testing.T) {
-	r := NewRegistry(nil)
-	sr := r.WithPrefix("myprefix").
-		WithTags(map[string]string{"ololo": "trololo"})
-
-	// must panic on empty name
-	assert.Panics(t, func() { r.Histogram("", nil) })
-
-	cnt := sr.Histogram("myhistogram", metrics.NewBuckets(1, 3, 5))
-
-	cnt.RecordValue(2)
-	cnt.RecordValue(4)
-
-	mr, err := r.Gather()
-	assert.NoError(t, err)
-
-	assert.IsType(t, mr, []*dto.MetricFamily{})
-
-	expected := []*dto.MetricFamily{
-		{
-			Name: ptr.String("myprefix_myhistogram"),
-			Help: ptr.String(""),
-			Type: func(mt dto.MetricType) *dto.MetricType { return &mt }(dto.MetricType_HISTOGRAM),
-			Metric: []*dto.Metric{
-				{
-					Label: []*dto.LabelPair{{Name: ptr.String("ololo"), Value: ptr.String("trololo")}},
-					Histogram: &dto.Histogram{
-						SampleCount: ptr.Uint64(2),
-						SampleSum:   ptr.Float64(6),
-						Bucket: []*dto.Bucket{
-							{CumulativeCount: ptr.Uint64(0), UpperBound: ptr.Float64(1)},
-							{CumulativeCount: ptr.Uint64(1), UpperBound: ptr.Float64(3)},
-							{CumulativeCount: ptr.Uint64(2), UpperBound: ptr.Float64(5)},
-						},
-					},
-				},
-			},
-		},
-	}
-	assertpb.Equal(t, expected, mr)
-}
-
-func TestRegistry_Timer(t *testing.T) {
-	r := NewRegistry(nil)
-	sr := r.WithPrefix("myprefix").
-		WithTags(map[string]string{"ololo": "trololo"})
-
-	// must panic on empty name
-	assert.Panics(t, func() { r.Timer("") })
-
-	cnt := sr.Timer("mytimer")
-	cnt.RecordDuration(42 * time.Second)
-
-	mr, err := r.Gather()
-	assert.NoError(t, err)
-
-	assert.IsType(t, mr, []*dto.MetricFamily{})
-
-	expected := []*dto.MetricFamily{
-		{
-			Name: ptr.String("myprefix_mytimer"),
-			Help: ptr.String(""),
-			Type: func(mt dto.MetricType) *dto.MetricType { return &mt }(dto.MetricType_GAUGE),
-			Metric: []*dto.Metric{
-				{
-					Label: []*dto.LabelPair{{Name: ptr.String("ololo"), Value: ptr.String("trololo")}},
-					Gauge: &dto.Gauge{Value: ptr.Float64(42)},
-				},
-			},
-		},
-	}
-	assertpb.Equal(t, expected, mr)
-}
-
-func TestRegistry_WithPrefix(t *testing.T) {
-	testCases := []struct {
-		r        metrics.Registry
-		expected string
-	}{
-		{
-			r: func() metrics.Registry {
-				return NewRegistry(nil)
-			}(),
-			expected: "",
-		},
-		{
-			r: func() metrics.Registry {
-				return NewRegistry(nil).WithPrefix("myprefix")
-			}(),
-			expected: "myprefix",
-		},
-		{
-			r: func() metrics.Registry {
-				return NewRegistry(nil).WithPrefix("__myprefix_")
-			}(),
-			expected: "myprefix",
-		},
-		{
-			r: func() metrics.Registry {
-				return NewRegistry(nil).WithPrefix("__myprefix_").WithPrefix("mysubprefix______")
-			}(),
-			expected: "myprefix_mysubprefix",
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run("", func(t *testing.T) {
-			assert.Equal(t, tc.expected, tc.r.(*Registry).prefix)
-		})
-	}
-}
-
-func TestRegistry_WithTags(t *testing.T) {
-	testCases := []struct {
-		r        metrics.Registry
-		expected map[string]string
-	}{
-		{
-			r: func() metrics.Registry {
-				return NewRegistry(nil)
-			}(),
-			expected: map[string]string{},
-		},
-		{
-			r: func() metrics.Registry {
-				return NewRegistry(nil).WithTags(map[string]string{"shimba": "boomba"})
-			}(),
-			expected: map[string]string{"shimba": "boomba"},
-		},
-		{
-			r: func() metrics.Registry {
-				return NewRegistry(nil).
-					WithTags(map[string]string{"shimba": "boomba"}).
-					WithTags(map[string]string{"looken": "tooken"})
-			}(),
-			expected: map[string]string{
-				"shimba": "boomba",
-				"looken": "tooken",
-			},
-		},
-		{
-			r: func() metrics.Registry {
-				return NewRegistry(nil).
-					WithTags(map[string]string{"shimba": "boomba"}).
-					WithTags(map[string]string{"looken": "tooken"}).
-					WithTags(map[string]string{"shimba": "cooken"})
-			}(),
-			expected: map[string]string{
-				"shimba": "cooken",
-				"looken": "tooken",
-			},
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run("", func(t *testing.T) {
-			assert.Equal(t, tc.expected, tc.r.(*Registry).tags)
-		})
-	}
-}
-
-func TestRegistry_WithTags_NoPanic(t *testing.T) {
-	_ = NewRegistry(nil).WithTags(map[string]string{"foo": "bar"})
-	_ = NewRegistry(nil).WithTags(map[string]string{"foo": "bar"})
-}
-
-func TestRegistry_Counter_NoPanic(t *testing.T) {
-	r := NewRegistry(nil)
-	sr := r.WithPrefix("myprefix").
-		WithTags(map[string]string{"ololo": "trololo"})
-	cntrRaz := sr.Counter("mycounter").(*Counter)
-	cntrDvaz := sr.Counter("mycounter").(*Counter)
-	assert.Equal(t, cntrRaz.cnt, cntrDvaz.cnt)
-	cntrRaz.Add(100)
-	cntrDvaz.Add(100)
-	mr, err := r.Gather()
-	assert.NoError(t, err)
-	expected := []*dto.MetricFamily{
-		{
-			Name: ptr.String("myprefix_mycounter"),
-			Help: ptr.String(""),
-			Type: func(mt dto.MetricType) *dto.MetricType { return &mt }(dto.MetricType_COUNTER),
-			Metric: []*dto.Metric{
-				{
-					Label:   []*dto.LabelPair{{Name: ptr.String("ololo"), Value: ptr.String("trololo")}},
-					Counter: &dto.Counter{Value: ptr.Float64(200)},
-				},
-			},
-		},
-	}
-	assertpb.Equal(t, expected, mr)
-}
-
-func TestRegistry_NameSanitizer(t *testing.T) {
-	testCases := []struct {
-		opts *RegistryOpts
-		name string
-		want string
-	}{
-		{
-			opts: nil,
-			name: "some_name",
-			want: "some_name",
-		},
-		{
-			opts: NewRegistryOpts().SetNameSanitizer(func(s string) string {
-				return strings.ReplaceAll(s, "/", "_")
-			}),
-			name: "other/name",
-			want: "other_name",
-		},
-	}
-
-	for _, tc := range testCases {
-		r := NewRegistry(tc.opts)
-		_ = r.Counter(tc.name)
-		mfs, err := r.Gather()
-		assert.NoError(t, err)
-		assert.NotEmpty(t, mfs)
-
-		assert.Equal(t, tc.want, *mfs[0].Name)
-	}
-}
diff --git a/library/go/core/metrics/prometheus/timer.go b/library/go/core/metrics/prometheus/timer.go
deleted file mode 100644
index 3350e5a61d..0000000000
--- a/library/go/core/metrics/prometheus/timer.go
+++ /dev/null
@@ -1,19 +0,0 @@
-package prometheus
-
-import (
-	"time"
-
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/ydb-platform/ydb/library/go/core/metrics"
-)
-
-var _ metrics.Timer = (*Timer)(nil)
-
-// Timer measures gauge duration.
-type Timer struct {
-	gg prometheus.Gauge
-}
-
-func (t Timer) RecordDuration(value time.Duration) {
-	t.gg.Set(value.Seconds())
-}
diff --git a/library/go/core/metrics/prometheus/timer_test.go b/library/go/core/metrics/prometheus/timer_test.go
deleted file mode 100644
index a520b6f477..0000000000
--- a/library/go/core/metrics/prometheus/timer_test.go
+++ /dev/null
@@ -1,24 +0,0 @@
-package prometheus
-
-import (
-	"testing"
-	"time"
-
-	"github.com/prometheus/client_golang/prometheus"
-	dto "github.com/prometheus/client_model/go"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestTimer_RecordDuration(t *testing.T) {
-	g := &Timer{gg: prometheus.NewGauge(prometheus.GaugeOpts{
-		Name: "test_timer_record_duration",
-	})}
-
-	g.RecordDuration(42 * time.Second)
-
-	var res dto.Metric
-	err := g.gg.Write(&res)
-
-	assert.NoError(t, err)
-	assert.Equal(t, float64(42), res.GetGauge().GetValue())
-}
diff --git a/library/go/core/metrics/prometheus/vec.go b/library/go/core/metrics/prometheus/vec.go
deleted file mode 100644
index 731c7b752a..0000000000
--- a/library/go/core/metrics/prometheus/vec.go
+++ /dev/null
@@ -1,248 +0,0 @@
-package prometheus
-
-import (
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/ydb-platform/ydb/library/go/core/metrics"
-	"github.com/ydb-platform/ydb/library/go/core/metrics/internal/pkg/metricsutil"
-	"github.com/ydb-platform/ydb/library/go/core/xerrors"
-)
-
-var _ metrics.CounterVec = (*CounterVec)(nil)
-
-// CounterVec wraps prometheus.CounterVec
-// and implements metrics.CounterVec interface.
-type CounterVec struct {
-	vec *prometheus.CounterVec
-}
-
-// CounterVec creates a new counters vector with given metric name and
-// partitioned by the given label names.
-func (r *Registry) CounterVec(name string, labels []string) metrics.CounterVec {
-	name = r.sanitizeName(name)
-	vec := prometheus.NewCounterVec(prometheus.CounterOpts{
-		Namespace:   r.prefix,
-		Name:        name,
-		ConstLabels: r.tags,
-	}, labels)
-
-	if err := r.rg.Register(vec); err != nil {
-		var existErr prometheus.AlreadyRegisteredError
-		if xerrors.As(err, &existErr) {
-			return &CounterVec{vec: existErr.ExistingCollector.(*prometheus.CounterVec)}
-		}
-		panic(err)
-	}
-
-	return &CounterVec{vec: vec}
-}
-
-// With creates new or returns existing counter with given tags from vector.
-// It will panic if tags keys set is not equal to vector labels.
-func (v *CounterVec) With(tags map[string]string) metrics.Counter {
-	return &Counter{cnt: v.vec.With(tags)}
-}
-
-// Reset deletes all metrics in this vector.
-func (v *CounterVec) Reset() {
-	v.vec.Reset()
-}
-
-var _ metrics.GaugeVec = (*GaugeVec)(nil)
-
-// GaugeVec wraps prometheus.GaugeVec
-// and implements metrics.GaugeVec interface.
-type GaugeVec struct {
-	vec *prometheus.GaugeVec
-}
-
-// GaugeVec creates a new gauges vector with given metric name and
-// partitioned by the given label names.
-func (r *Registry) GaugeVec(name string, labels []string) metrics.GaugeVec {
-	name = r.sanitizeName(name)
-	vec := prometheus.NewGaugeVec(prometheus.GaugeOpts{
-		Namespace:   r.prefix,
-		Name:        name,
-		ConstLabels: r.tags,
-	}, labels)
-
-	if err := r.rg.Register(vec); err != nil {
-		var existErr prometheus.AlreadyRegisteredError
-		if xerrors.As(err, &existErr) {
-			return &GaugeVec{vec: existErr.ExistingCollector.(*prometheus.GaugeVec)}
-		}
-		panic(err)
-	}
-
-	return &GaugeVec{vec: vec}
-}
-
-// With creates new or returns existing gauge with given tags from vector.
-// It will panic if tags keys set is not equal to vector labels.
-func (v *GaugeVec) With(tags map[string]string) metrics.Gauge {
-	return &Gauge{gg: v.vec.With(tags)}
-}
-
-// Reset deletes all metrics in this vector.
-func (v *GaugeVec) Reset() {
-	v.vec.Reset()
-}
-
-// IntGaugeVec wraps prometheus.GaugeVec
-// and implements metrics.IntGaugeVec interface.
-type IntGaugeVec struct {
-	vec *prometheus.GaugeVec
-}
-
-// IntGaugeVec creates a new gauges vector with given metric name and
-// partitioned by the given label names.
-func (r *Registry) IntGaugeVec(name string, labels []string) metrics.IntGaugeVec {
-	name = r.sanitizeName(name)
-	vec := prometheus.NewGaugeVec(prometheus.GaugeOpts{
-		Namespace:   r.prefix,
-		Name:        name,
-		ConstLabels: r.tags,
-	}, labels)
-
-	if err := r.rg.Register(vec); err != nil {
-		var existErr prometheus.AlreadyRegisteredError
-		if xerrors.As(err, &existErr) {
-			return &IntGaugeVec{vec: existErr.ExistingCollector.(*prometheus.GaugeVec)}
-		}
-		panic(err)
-	}
-
-	return &IntGaugeVec{vec: vec}
-}
-
-// With creates new or returns existing gauge with given tags from vector.
-// It will panic if tags keys set is not equal to vector labels.
-func (v *IntGaugeVec) With(tags map[string]string) metrics.IntGauge {
-	return &IntGauge{Gauge{gg: v.vec.With(tags)}}
-}
-
-// Reset deletes all metrics in this vector.
-func (v *IntGaugeVec) Reset() {
-	v.vec.Reset()
-}
-
-var _ metrics.TimerVec = (*TimerVec)(nil)
-
-// TimerVec wraps prometheus.GaugeVec
-// and implements metrics.TimerVec interface.
-type TimerVec struct {
-	vec *prometheus.GaugeVec
-}
-
-// TimerVec creates a new timers vector with given metric name and
-// partitioned by the given label names.
-func (r *Registry) TimerVec(name string, labels []string) metrics.TimerVec {
-	name = r.sanitizeName(name)
-	vec := prometheus.NewGaugeVec(prometheus.GaugeOpts{
-		Namespace:   r.prefix,
-		Name:        name,
-		ConstLabels: r.tags,
-	}, labels)
-
-	if err := r.rg.Register(vec); err != nil {
-		var existErr prometheus.AlreadyRegisteredError
-		if xerrors.As(err, &existErr) {
-			return &TimerVec{vec: existErr.ExistingCollector.(*prometheus.GaugeVec)}
-		}
-		panic(err)
-	}
-
-	return &TimerVec{vec: vec}
-}
-
-// With creates new or returns existing timer with given tags from vector.
-// It will panic if tags keys set is not equal to vector labels.
-func (v *TimerVec) With(tags map[string]string) metrics.Timer {
-	return &Timer{gg: v.vec.With(tags)}
-}
-
-// Reset deletes all metrics in this vector.
-func (v *TimerVec) Reset() {
-	v.vec.Reset()
-}
-
-var _ metrics.HistogramVec = (*HistogramVec)(nil)
-
-// HistogramVec wraps prometheus.HistogramVec
-// and implements metrics.HistogramVec interface.
-type HistogramVec struct {
-	vec *prometheus.HistogramVec
-}
-
-// HistogramVec creates a new histograms vector with given metric name and buckets and
-// partitioned by the given label names.
-func (r *Registry) HistogramVec(name string, buckets metrics.Buckets, labels []string) metrics.HistogramVec {
-	name = r.sanitizeName(name)
-	vec := prometheus.NewHistogramVec(prometheus.HistogramOpts{
-		Namespace:   r.prefix,
-		Name:        name,
-		ConstLabels: r.tags,
-		Buckets:     metricsutil.BucketsBounds(buckets),
-	}, labels)
-
-	if err := r.rg.Register(vec); err != nil {
-		var existErr prometheus.AlreadyRegisteredError
-		if xerrors.As(err, &existErr) {
-			return &HistogramVec{vec: existErr.ExistingCollector.(*prometheus.HistogramVec)}
-		}
-		panic(err)
-	}
-
-	return &HistogramVec{vec: vec}
-}
-
-// With creates new or returns existing histogram with given tags from vector.
-// It will panic if tags keys set is not equal to vector labels.
-func (v *HistogramVec) With(tags map[string]string) metrics.Histogram {
-	return &Histogram{hm: v.vec.With(tags)}
-}
-
-// Reset deletes all metrics in this vector.
-func (v *HistogramVec) Reset() {
-	v.vec.Reset()
-}
-
-var _ metrics.TimerVec = (*DurationHistogramVec)(nil)
-
-// DurationHistogramVec wraps prometheus.HistogramVec
-// and implements metrics.TimerVec interface.
-type DurationHistogramVec struct {
-	vec *prometheus.HistogramVec
-}
-
-// DurationHistogramVec creates a new duration histograms vector with given metric name and buckets and
-// partitioned by the given label names.
-func (r *Registry) DurationHistogramVec(name string, buckets metrics.DurationBuckets, labels []string) metrics.TimerVec {
-	name = r.sanitizeName(name)
-	vec := prometheus.NewHistogramVec(prometheus.HistogramOpts{
-		Namespace:   r.prefix,
-		Name:        name,
-		ConstLabels: r.tags,
-		Buckets:     metricsutil.DurationBucketsBounds(buckets),
-	}, labels)
-
-	if err := r.rg.Register(vec); err != nil {
-		var existErr prometheus.AlreadyRegisteredError
-		if xerrors.As(err, &existErr) {
-			return &DurationHistogramVec{vec: existErr.ExistingCollector.(*prometheus.HistogramVec)}
-		}
-		panic(err)
-	}
-
-	return &DurationHistogramVec{vec: vec}
-}
-
-// With creates new or returns existing duration histogram with given tags from vector.
-// It will panic if tags keys set is not equal to vector labels.
-func (v *DurationHistogramVec) With(tags map[string]string) metrics.Timer {
-	return &Histogram{hm: v.vec.With(tags)}
-}
-
-// Reset deletes all metrics in this vector.
-func (v *DurationHistogramVec) Reset() {
-	v.vec.Reset()
-}
diff --git a/library/go/core/metrics/prometheus/vec_test.go b/library/go/core/metrics/prometheus/vec_test.go
deleted file mode 100644
index ccf088c17a..0000000000
--- a/library/go/core/metrics/prometheus/vec_test.go
+++ /dev/null
@@ -1,137 +0,0 @@
-package prometheus
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/ydb-platform/ydb/library/go/core/metrics"
-)
-
-func TestCounterVec(t *testing.T) {
-	rg := NewRegistry(NewRegistryOpts())
-	vec := rg.CounterVec("ololo", []string{"shimba", "looken"})
-	mt := vec.With(map[string]string{
-		"shimba": "boomba",
-		"looken": "tooken",
-	})
-
-	assert.IsType(t, &CounterVec{}, vec)
-	assert.IsType(t, &Counter{}, mt)
-
-	vec.Reset()
-
-	metrics, err := rg.Gather()
-	assert.NoError(t, err)
-	assert.Empty(t, metrics)
-}
-
-func TestCounterVec_RegisterAgain(t *testing.T) {
-	rg := NewRegistry(NewRegistryOpts())
-	vec1 := rg.CounterVec("ololo", []string{"shimba", "looken"}).(*CounterVec)
-	vec2 := rg.CounterVec("ololo", []string{"shimba", "looken"}).(*CounterVec)
-	assert.Same(t, vec1.vec, vec2.vec)
-}
-
-func TestGaugeVec(t *testing.T) {
-	rg := NewRegistry(NewRegistryOpts())
-	vec := rg.GaugeVec("ololo", []string{"shimba", "looken"})
-	mt := vec.With(map[string]string{
-		"shimba": "boomba",
-		"looken": "tooken",
-	})
-
-	assert.IsType(t, &GaugeVec{}, vec)
-	assert.IsType(t, &Gauge{}, mt)
-
-	vec.Reset()
-
-	metrics, err := rg.Gather()
-	assert.NoError(t, err)
-	assert.Empty(t, metrics)
-}
-
-func TestGaugeVec_RegisterAgain(t *testing.T) {
-	rg := NewRegistry(NewRegistryOpts())
-	vec1 := rg.GaugeVec("ololo", []string{"shimba", "looken"}).(*GaugeVec)
-	vec2 := rg.GaugeVec("ololo", []string{"shimba", "looken"}).(*GaugeVec)
-	assert.Same(t, vec1.vec, vec2.vec)
-}
-
-func TestTimerVec(t *testing.T) {
-	rg := NewRegistry(NewRegistryOpts())
-	vec := rg.TimerVec("ololo", []string{"shimba", "looken"})
-	mt := vec.With(map[string]string{
-		"shimba": "boomba",
-		"looken": "tooken",
-	})
-
-	assert.IsType(t, &TimerVec{}, vec)
-	assert.IsType(t, &Timer{}, mt)
-
-	vec.Reset()
-
-	metrics, err := rg.Gather()
-	assert.NoError(t, err)
-	assert.Empty(t, metrics)
-}
-
-func TestTimerVec_RegisterAgain(t *testing.T) {
-	rg := NewRegistry(NewRegistryOpts())
-	vec1 := rg.TimerVec("ololo", []string{"shimba", "looken"}).(*TimerVec)
-	vec2 := rg.TimerVec("ololo", []string{"shimba", "looken"}).(*TimerVec)
-	assert.Same(t, vec1.vec, vec2.vec)
-}
-
-func TestHistogramVec(t *testing.T) {
-	rg := NewRegistry(NewRegistryOpts())
-	buckets := metrics.NewBuckets(1, 2, 3)
-	vec := rg.HistogramVec("ololo", buckets, []string{"shimba", "looken"})
-	mt := vec.With(map[string]string{
-		"shimba": "boomba",
-		"looken": "tooken",
-	})
-
-	assert.IsType(t, &HistogramVec{}, vec)
-	assert.IsType(t, &Histogram{}, mt)
-
-	vec.Reset()
-
-	metrics, err := rg.Gather()
-	assert.NoError(t, err)
-	assert.Empty(t, metrics)
-}
-
-func TestHistogramVec_RegisterAgain(t *testing.T) {
-	rg := NewRegistry(NewRegistryOpts())
-	buckets := metrics.NewBuckets(1, 2, 3)
-	vec1 := rg.HistogramVec("ololo", buckets, []string{"shimba", "looken"}).(*HistogramVec)
-	vec2 := rg.HistogramVec("ololo", buckets, []string{"shimba", "looken"}).(*HistogramVec)
-	assert.Same(t, vec1.vec, vec2.vec)
-}
-
-func TestDurationHistogramVec(t *testing.T) {
-	rg := NewRegistry(NewRegistryOpts())
-	buckets := metrics.NewDurationBuckets(1, 2, 3)
-	vec := rg.DurationHistogramVec("ololo", buckets, []string{"shimba", "looken"})
-	mt := vec.With(map[string]string{
-		"shimba": "boomba",
-		"looken": "tooken",
-	})
-
-	assert.IsType(t, &DurationHistogramVec{}, vec)
-	assert.IsType(t, &Histogram{}, mt)
-
-	vec.Reset()
-
-	metrics, err := rg.Gather()
-	assert.NoError(t, err)
-	assert.Empty(t, metrics)
-}
-
-func TestDurationHistogramVec_RegisterAgain(t *testing.T) {
-	rg := NewRegistry(NewRegistryOpts())
-	buckets := metrics.NewDurationBuckets(1, 2, 3)
-	vec1 := rg.DurationHistogramVec("ololo", buckets, []string{"shimba", "looken"}).(*DurationHistogramVec)
-	vec2 := rg.DurationHistogramVec("ololo", buckets, []string{"shimba", "looken"}).(*DurationHistogramVec)
-	assert.Same(t, vec1.vec, vec2.vec)
-}
diff --git a/library/go/core/metrics/prometheus/ya.make b/library/go/core/metrics/prometheus/ya.make
deleted file mode 100644
index b012835f4b..0000000000
--- a/library/go/core/metrics/prometheus/ya.make
+++ /dev/null
@@ -1,25 +0,0 @@
-GO_LIBRARY()
-
-SRCS(
-    counter.go
-    gauge.go
-    int_gauge.go
-    histogram.go
-    registry.go
-    registry_opts.go
-    timer.go
-    vec.go
-)
-
-GO_TEST_SRCS(
-    counter_test.go
-    gauge_test.go
-    histogram_test.go
-    registry_test.go
-    timer_test.go
-    vec_test.go
-)
-
-END()
-
-RECURSE(gotest)