diff --git a/api/api.go b/api/api.go
index 7a9eeea..34efc1a 100644
--- a/api/api.go
+++ b/api/api.go
@@ -85,18 +85,18 @@ func main() {
 	penyakitRepository := repository.NewPenyakit(postgres)
 	reportedRepository := repository.NewReported(mongo.Conn, conf)
 
-	userService := service.NewUser(userRepository, *gauge)
-	obatService := service.NewObat(obatRepository, *gauge)
-	kunjunganServices := service.NewKunjungan(kunjunganRepository, reportedRepository, *gauge)
-	penyakitService := service.NewPenyakit(penyakitRepository, *gauge)
-	adminService := service.NewAdmin(obatRepository, penyakitRepository, reportedRepository, userRepository, gauge)
+	userService := service.NewUser(userRepository)
+	obatService := service.NewObat(obatRepository)
+	kunjunganServices := service.NewKunjungan(kunjunganRepository, reportedRepository)
+	penyakitService := service.NewPenyakit(penyakitRepository)
+	adminService := service.NewAdmin(obatRepository, penyakitRepository, reportedRepository, userRepository)
 
 	api := API{
-		obat:      handler.NewObat(obatService),
-		user:      handler.NewUser(userService),
-		kunjungan: handler.NewKunjungan(kunjunganServices),
-		penyakit:  handler.NewPenyakit(penyakitService),
-		admin:     handler.NewAdmin(adminService),
+		obat:      handler.NewObat(obatService, gauge),
+		user:      handler.NewUser(userService, gauge),
+		kunjungan: handler.NewKunjungan(kunjunganServices, gauge),
+		penyakit:  handler.NewPenyakit(penyakitService, gauge),
+		admin:     handler.NewAdmin(adminService, gauge),
 	}
 
 	routes := mux.NewRouter()
diff --git a/api/http/admin.go b/api/http/admin.go
index 947145b..6038758 100644
--- a/api/http/admin.go
+++ b/api/http/admin.go
@@ -5,10 +5,13 @@ import (
 	"net/http"
 	"strconv"
 	"strings"
+	"time"
 
+	"github.com/prometheus/client_golang/prometheus"
 	"github.com/rulanugrh/larissa/internal/entity/domain"
 	"github.com/rulanugrh/larissa/internal/service"
 	"github.com/rulanugrh/larissa/internal/util"
+	"github.com/rulanugrh/larissa/pkg"
 )
 
 type AdminInterface interface {
@@ -23,11 +26,13 @@ type AdminInterface interface {
 
 type admin struct {
 	service service.AdminInterface
+	gauge *pkg.Data
 }
 
-func NewAdmin(service service.AdminInterface) AdminInterface {
+func NewAdmin(service service.AdminInterface, gauge *pkg.Data) AdminInterface {
 	return &admin{
 		service: service,
+		gauge: gauge,
 	}
 }
 
@@ -35,6 +40,7 @@ func(a *admin) Penyakit(w http.ResponseWriter, r *http.Request) {
 	var req domain.Penyakit
 	err := json.NewDecoder(r.Body).Decode(&req)
 	if err != nil {
+		a.gauge.PenyakitHistory.With(prometheus.Labels{"code": "500", "method": "POST", "type": "create"}).Observe(time.Since(time.Now()).Seconds())
 		response := util.WriteJSON(util.InternalServerError("cannot read request body"))
 		w.WriteHeader(500)
 		w.Write(response)
@@ -43,12 +49,17 @@ func(a *admin) Penyakit(w http.ResponseWriter, r *http.Request) {
 
 	data, err := a.service.CreatePenyakit(req)
 	if err != nil {
+		a.gauge.PenyakitHistory.With(prometheus.Labels{"code": "400", "method": "POST", "type": "create"}).Observe(time.Since(time.Now()).Seconds())
 		response := util.WriteJSON(util.BadRequest(err.Error()))
 		w.WriteHeader(400)
 		w.Write(response)
 		return
 	}
 
+	a.gauge.Penyakit.Inc()
+	a.gauge.PenyakitHistory.With(prometheus.Labels{"code": "200", "method": "POST", "type": "create"}).Observe(time.Since(time.Now()).Seconds())
+	a.gauge.PenyakitUpgrade.With(prometheus.Labels{"type": "create"}).Inc()
+
 	response := util.WriteJSON(util.Success("success add to database", data))
 	w.WriteHeader(200)
 	w.Write(response)
@@ -59,6 +70,7 @@ func(a *admin) Obat(w http.ResponseWriter, r *http.Request) {
 	var req domain.Obat
 	err := json.NewDecoder(r.Body).Decode(&req)
 	if err != nil {
+		a.gauge.ObatHistory.With(prometheus.Labels{"code": "500", "method": "POST", "type": "create"}).Observe(time.Since(time.Now()).Seconds())
 		response := util.WriteJSON(util.InternalServerError("cannot read request body"))
 		w.WriteHeader(500)
 		w.Write(response)
@@ -67,12 +79,17 @@ func(a *admin) Obat(w http.ResponseWriter, r *http.Request) {
 
 	data, err := a.service.CreateObat(req)
 	if err != nil {
+		a.gauge.ObatHistory.With(prometheus.Labels{"code": "400", "method": "POST", "type": "create"}).Observe(time.Since(time.Now()).Seconds())
 		response := util.WriteJSON(util.BadRequest(err.Error()))
 		w.WriteHeader(400)
 		w.Write(response)
 		return
 	}
 
+	a.gauge.Obat.Inc()
+	a.gauge.ObatHistory.With(prometheus.Labels{"code": "200", "method": "POST", "type": "create"}).Observe(time.Since(time.Now()).Seconds())
+	a.gauge.ObatUpgrade.With(prometheus.Labels{"type": "create"}).Inc()
+
 	response := util.WriteJSON(util.Success("success add to database", data))
 	w.WriteHeader(200)
 	w.Write(response)
@@ -83,6 +100,7 @@ func(a *admin) UpdateObat(w http.ResponseWriter, r *http.Request) {
 	var req domain.Obat
 	err := json.NewDecoder(r.Body).Decode(&req)
 	if err != nil {
+		a.gauge.ObatHistory.With(prometheus.Labels{"code": "500", "method": "PUT", "type": "update"}).Observe(time.Since(time.Now()).Seconds())
 		response := util.WriteJSON(util.InternalServerError("cannot read request body"))
 		w.WriteHeader(500)
 		w.Write(response)
@@ -97,12 +115,16 @@ func(a *admin) UpdateObat(w http.ResponseWriter, r *http.Request) {
 
 	data, err := a.service.UpdateObat(uint(id), req)
 	if err != nil {
+		a.gauge.ObatHistory.With(prometheus.Labels{"code": "400", "method": "PUT", "type": "update"}).Observe(time.Since(time.Now()).Seconds())
 		response := util.WriteJSON(util.BadRequest(err.Error()))
 		w.WriteHeader(400)
 		w.Write(response)
 		return
 	}
 
+	a.gauge.ObatHistory.With(prometheus.Labels{"code": "200", "method": "PUT", "type": "update"}).Observe(time.Since(time.Now()).Seconds())
+	a.gauge.ObatUpgrade.With(prometheus.Labels{"type": "update"}).Inc()
+
 	response := util.WriteJSON(util.Success("success update obat", data))
 	w.WriteHeader(200)
 	w.Write(response)
@@ -118,13 +140,16 @@ func(a *admin) DeleteObat(w http.ResponseWriter, r *http.Request) {
 
 	err = a.service.DeleteObat(uint(id))
 	if err != nil {
+		a.gauge.ObatHistory.With(prometheus.Labels{"code": "400", "method": "DELETE", "type": "delete"}).Observe(time.Since(time.Now()).Seconds())
 		response := util.WriteJSON(util.BadRequest(err.Error()))
 		w.WriteHeader(400)
 		w.Write(response)
 		return
 	}
 
-	w.WriteHeader(200)
+	a.gauge.ObatHistory.With(prometheus.Labels{"code": "204", "method": "DELETE", "type": "delete"}).Observe(time.Since(time.Now()).Seconds())
+	a.gauge.ObatUpgrade.With(prometheus.Labels{"type": "delete"}).Inc()
+	w.WriteHeader(204)
 	w.Write([]byte("successfull delete data"))
 	return
 }
@@ -138,13 +163,16 @@ func(a *admin) DeletePenyakit(w http.ResponseWriter, r *http.Request) {
 
 	err = a.service.DeletePenyakit(uint(id))
 	if err != nil {
+		a.gauge.PenyakitHistory.With(prometheus.Labels{"code": "400", "method": "DELETE", "type": "delete"}).Observe(time.Since(time.Now()).Seconds())
 		response := util.WriteJSON(util.BadRequest(err.Error()))
 		w.WriteHeader(400)
 		w.Write(response)
 		return
 	}
 
-	w.WriteHeader(200)
+	a.gauge.PenyakitHistory.With(prometheus.Labels{"code": "204", "method": "DELETE", "type": "delete"}).Observe(time.Since(time.Now()).Seconds())
+	a.gauge.PenyakitUpgrade.With(prometheus.Labels{"type": "delete"}).Inc()
+	w.WriteHeader(204)
 	w.Write([]byte("successfull delete data"))
 	return
 }
@@ -152,12 +180,16 @@ func(a *admin) DeletePenyakit(w http.ResponseWriter, r *http.Request) {
 func(a *admin) Reported(w http.ResponseWriter, r *http.Request) {
 	data, err := a.service.Reported()
 	if err != nil {
+		a.gauge.KunjunganHistory.With(prometheus.Labels{"code": "400", "method": "GET", "type": "get"}).Observe(time.Since(time.Now()).Seconds())
 		response := util.WriteJSON(util.BadRequest(err.Error()))
 		w.WriteHeader(400)
 		w.Write(response)
 		return
 	}
 
+	a.gauge.KunjunganHistory.With(prometheus.Labels{"code": "200", "method": "GET", "type": "get"}).Observe(time.Since(time.Now()).Seconds())
+	a.gauge.Kunjungan.Set(float64(len(*data)))
+
 	response := util.WriteJSON(util.Success("data reported found", data))
 	w.WriteHeader(200)
 	w.Write(response)
@@ -167,12 +199,17 @@ func(a *admin) Reported(w http.ResponseWriter, r *http.Request) {
 func(a *admin) ListAllUser(w http.ResponseWriter, r *http.Request) {
 	data, err := a.service.ListAllUser()
 	if err != nil {
+		a.gauge.UserHistory.With(prometheus.Labels{"code": "400", "method": "GET", "type": "get"}).Observe(time.Since(time.Now()).Seconds())
+
 		response := util.WriteJSON(util.BadRequest(err.Error()))
 		w.WriteHeader(400)
 		w.Write(response)
 		return
 	}
 
+	a.gauge.UserHistory.With(prometheus.Labels{"code": "200", "method": "GET", "type": "get"}).Observe(time.Since(time.Now()).Seconds())
+	a.gauge.User.Set(float64(len(*data)))
+
 	response := util.WriteJSON(util.Success("data user found", data))
 	w.WriteHeader(200)
 	w.Write(response)
diff --git a/api/http/kunjungan.go b/api/http/kunjungan.go
index 765d77a..a4750a2 100644
--- a/api/http/kunjungan.go
+++ b/api/http/kunjungan.go
@@ -3,11 +3,14 @@ package handler
 import (
 	"encoding/json"
 	"net/http"
+	"time"
 
+	"github.com/prometheus/client_golang/prometheus"
 	"github.com/rulanugrh/larissa/internal/entity/domain"
 	"github.com/rulanugrh/larissa/internal/middleware"
 	"github.com/rulanugrh/larissa/internal/service"
 	"github.com/rulanugrh/larissa/internal/util"
+	"github.com/rulanugrh/larissa/pkg"
 )
 
 type KunjunganInterface interface {
@@ -17,11 +20,13 @@ type KunjunganInterface interface {
 
 type kunjungan struct {
 	service service.KunjunganInterface
+	gauge *pkg.Data
 }
 
-func NewKunjungan(service service.KunjunganInterface) KunjunganInterface {
+func NewKunjungan(service service.KunjunganInterface, gauge *pkg.Data) KunjunganInterface {
 	return &kunjungan{
 		service: service,
+		gauge: gauge,
 	}
 }
 
@@ -29,6 +34,7 @@ func(k *kunjungan) Create(w http.ResponseWriter, r *http.Request) {
 	var req domain.Kunjungan
 	err := json.NewDecoder(r.Body).Decode(&req)
 	if err != nil {
+		k.gauge.KunjunganHistory.With(prometheus.Labels{"code": "500", "method": "POST", "type": "create"}).Observe(time.Since(time.Now()).Seconds())
 		response := util.WriteJSON(util.InternalServerError("cannot read request body"))
 		w.WriteHeader(500)
 		w.Write(response)
@@ -37,12 +43,17 @@ func(k *kunjungan) Create(w http.ResponseWriter, r *http.Request) {
 
 	data, err := k.service.Create(req)
 	if err != nil {
+		k.gauge.KunjunganHistory.With(prometheus.Labels{"code": "400", "method": "POST", "type": "create"}).Observe(time.Since(time.Now()).Seconds())
 		response := util.WriteJSON(util.BadRequest(err.Error()))
 		w.WriteHeader(400)
 		w.Write(response)
 		return
 	}
 
+	k.gauge.Kunjungan.Inc()
+	k.gauge.KunjunganHistory.With(prometheus.Labels{"code": "200", "method": "POST", "type": "create"}).Observe(time.Since(time.Now()).Seconds())
+	k.gauge.KunjunganUpgrade.With(prometheus.Labels{"type": "create"}).Inc()
+
 	response := util.WriteJSON(util.Created("recorde data kunjungan", data))
 	w.WriteHeader(201)
 	w.Write(response)
@@ -52,6 +63,7 @@ func(k *kunjungan) Create(w http.ResponseWriter, r *http.Request) {
 func(k *kunjungan) Find(w http.ResponseWriter, r *http.Request) {
 	id, err := middleware.GetUserID(r)
 	if err != nil {
+		k.gauge.KunjunganHistory.With(prometheus.Labels{"code": "401", "method": "GET", "type": "getByID"}).Observe(time.Since(time.Now()).Seconds())
 		response := util.WriteJSON(util.Unauthorized(err.Error()))
 		w.WriteHeader(401)
 		w.Write(response)
@@ -60,12 +72,16 @@ func(k *kunjungan) Find(w http.ResponseWriter, r *http.Request) {
 
 	data, err := k.service.Find(id)
 	if err != nil {
+		k.gauge.KunjunganHistory.With(prometheus.Labels{"code": "400", "method": "GET", "type": "getByID"}).Observe(time.Since(time.Now()).Seconds())
 		response := util.WriteJSON(util.BadRequest(err.Error()))
 		w.WriteHeader(400)
 		w.Write(response)
 		return
 	}
 
+	k.gauge.KunjunganHistory.With(prometheus.Labels{"code": "200", "method": "GET", "type": "getByID"}).Observe(time.Since(time.Now()).Seconds())
+	k.gauge.KunjunganUpgrade.With(prometheus.Labels{"type": "getByID"}).Inc()
+
 	response := util.WriteJSON(util.Success("find kunjungan by this user id", data))
 	w.WriteHeader(200)
 	w.Write(response)
diff --git a/api/http/obat.go b/api/http/obat.go
index 652e19c..3409824 100644
--- a/api/http/obat.go
+++ b/api/http/obat.go
@@ -4,9 +4,12 @@ import (
 	"net/http"
 	"strconv"
 	"strings"
+	"time"
 
+	"github.com/prometheus/client_golang/prometheus"
 	"github.com/rulanugrh/larissa/internal/service"
 	"github.com/rulanugrh/larissa/internal/util"
+	"github.com/rulanugrh/larissa/pkg"
 )
 
 type ObatInterface interface {
@@ -16,11 +19,13 @@ type ObatInterface interface {
 
 type obat struct {
 	service service.ObatInterface
+	gauge *pkg.Data
 }
 
-func NewObat(service service.ObatInterface) ObatInterface {
+func NewObat(service service.ObatInterface, gauge *pkg.Data) ObatInterface {
 	return &obat{
 		service: service,
+		gauge: gauge,
 	}
 }
 
@@ -30,15 +35,19 @@ func(o *obat) FindID(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(500)
 		return
 	}
-	
+
 	data, err := o.service.FindID(uint(id))
 	if err != nil {
+		o.gauge.ObatHistory.With(prometheus.Labels{"code": "400", "method": "GET", "type": "getByID"}).Observe(time.Since(time.Now()).Seconds())
+
 		response := util.WriteJSON(util.BadRequest(err.Error()))
 		w.WriteHeader(400)
 		w.Write(response)
 		return
 	}
 
+	o.gauge.ObatHistory.With(prometheus.Labels{"code": "200", "method": "GET", "type": "getByID"}).Observe(time.Since(time.Now()).Seconds())
+
 	response := util.WriteJSON(util.Success("find obat by this id", data))
 	w.WriteHeader(200)
 	w.Write(response)
@@ -48,14 +57,19 @@ func(o *obat) FindID(w http.ResponseWriter, r *http.Request) {
 func(o *obat) FindAll(w http.ResponseWriter, r *http.Request) {
 	data, err := o.service.FindAll()
 	if err != nil {
+		o.gauge.ObatHistory.With(prometheus.Labels{"code": "400", "method": "GET", "type": "get"}).Observe(time.Since(time.Now()).Seconds())
+
 		response := util.WriteJSON(util.BadRequest(err.Error()))
 		w.WriteHeader(400)
 		w.Write(response)
 		return
 	}
 
+	o.gauge.ObatHistory.With(prometheus.Labels{"code": "200", "method": "GET", "type": "get"}).Observe(time.Since(time.Now()).Seconds())
+	o.gauge.Obat.Set(float64(len(*data)))
+
 	response := util.WriteJSON(util.Success("sucessfull, obat found", data))
 	w.WriteHeader(200)
 	w.Write(response)
 	return
-}
\ No newline at end of file
+}
diff --git a/api/http/penyakit.go b/api/http/penyakit.go
index 030079a..d67f284 100644
--- a/api/http/penyakit.go
+++ b/api/http/penyakit.go
@@ -4,9 +4,12 @@ import (
 	"net/http"
 	"strconv"
 	"strings"
+	"time"
 
+	"github.com/prometheus/client_golang/prometheus"
 	"github.com/rulanugrh/larissa/internal/service"
 	"github.com/rulanugrh/larissa/internal/util"
+	"github.com/rulanugrh/larissa/pkg"
 )
 
 type PenyakitInterface interface {
@@ -16,23 +19,30 @@ type PenyakitInterface interface {
 
 type penyakit struct {
 	service service.PenyakitInterface
+	gauge *pkg.Data
 }
 
-func NewPenyakit(service service.PenyakitInterface) PenyakitInterface {
+func NewPenyakit(service service.PenyakitInterface, gauge *pkg.Data) PenyakitInterface {
 	return &penyakit{
 		service: service,
+		gauge: gauge,
 	}
 }
 
 func(p *penyakit) FindAll(w http.ResponseWriter, r *http.Request) {
 	data, err := p.service.FindAll()
 	if err != nil {
+		p.gauge.PenyakitHistory.With(prometheus.Labels{"code": "400", "method": "GET", "type": "get"}).Observe(time.Since(time.Now()).Seconds())
+
 		response := util.WriteJSON(util.BadRequest(err.Error()))
 		w.WriteHeader(400)
 		w.Write(response)
 		return
 	}
 
+	p.gauge.PenyakitHistory.With(prometheus.Labels{"code": "200", "method": "GET", "type": "get"}).Observe(time.Since(time.Now()).Seconds())
+	p.gauge.Penyakit.Set(float64(len(*data)))
+
 	response := util.WriteJSON(util.Success("data found", data))
 	w.WriteHeader(200)
 	w.Write(response)
@@ -47,12 +57,16 @@ func(p *penyakit) FindID(w http.ResponseWriter, r *http.Request) {
 
 	data, err := p.service.FindID(uint(id))
 	if err != nil {
+		p.gauge.PenyakitHistory.With(prometheus.Labels{"code": "400", "method": "GET", "type": "getByID"}).Observe(time.Since(time.Now()).Seconds())
+
 		response := util.WriteJSON(util.BadRequest(err.Error()))
 		w.WriteHeader(400)
 		w.Write(response)
 		return
 	}
 
+	p.gauge.PenyakitHistory.With(prometheus.Labels{"code": "200", "method": "GET", "type": "getByID"}).Observe(time.Since(time.Now()).Seconds())
+
 	response := util.WriteJSON(util.Success("data found", data))
 	w.WriteHeader(200)
 	w.Write(response)
diff --git a/api/http/user.go b/api/http/user.go
index 1b6994f..2e90081 100644
--- a/api/http/user.go
+++ b/api/http/user.go
@@ -3,11 +3,14 @@ package handler
 import (
 	"encoding/json"
 	"net/http"
+	"time"
 
+	"github.com/prometheus/client_golang/prometheus"
 	"github.com/rulanugrh/larissa/internal/entity/domain"
 	"github.com/rulanugrh/larissa/internal/middleware"
 	"github.com/rulanugrh/larissa/internal/service"
 	"github.com/rulanugrh/larissa/internal/util"
+	"github.com/rulanugrh/larissa/pkg"
 )
 
 type UserInterface interface {
@@ -18,11 +21,13 @@ type UserInterface interface {
 
 type user struct {
 	service service.UserInterface
+	gauge *pkg.Data
 }
 
-func NewUser(service service.UserInterface) UserInterface {
+func NewUser(service service.UserInterface, gauge *pkg.Data) UserInterface {
 	return &user{
 		service: service,
+		gauge: gauge,
 	}
 }
 
@@ -30,20 +35,27 @@ func(u *user) Register(w http.ResponseWriter, r *http.Request) {
 	var req domain.UserRegister
 	err := json.NewDecoder(r.Body).Decode(&req)
 	if err != nil {
+		u.gauge.UserHistory.With(prometheus.Labels{"code": "500", "method": "POST", "type": "register"}).Observe(time.Since(time.Now()).Seconds())
 		response := util.WriteJSON(util.InternalServerError("cannot read request body"))
-		w.WriteHeader(400)
+		w.WriteHeader(500)
 		w.Write(response)
 		return
 	}
 
 	data, err := u.service.Register(req)
 	if err != nil {
+		u.gauge.UserHistory.With(prometheus.Labels{"code": "400", "method": "POST", "type": "register"}).Observe(time.Since(time.Now()).Seconds())
+
 		response := util.WriteJSON(util.BadRequest(err.Error()))
 		w.WriteHeader(400)
 		w.Write(response)
 		return
 	}
 
+	u.gauge.User.Inc()
+	u.gauge.UserHistory.With(prometheus.Labels{"code": "200", "method": "POST", "type": "register"}).Observe(time.Since(time.Now()).Seconds())
+	u.gauge.UserUpgrade.With(prometheus.Labels{"type": "create"}).Inc()
+
 	response := util.WriteJSON(util.Created("success register account", data))
 	w.WriteHeader(201)
 	w.Write(response)
@@ -54,6 +66,8 @@ func(u *user) Login(w http.ResponseWriter, r *http.Request) {
 	var req domain.UserLogin
 	err := json.NewDecoder(r.Body).Decode(&req)
 	if err != nil {
+		u.gauge.UserHistory.With(prometheus.Labels{"code": "500", "method": "POST", "type": "login"}).Observe(time.Since(time.Now()).Seconds())
+
 		response := util.WriteJSON(util.InternalServerError("cannot read request body"))
 		w.WriteHeader(500)
 		w.Write(response)
@@ -62,6 +76,8 @@ func(u *user) Login(w http.ResponseWriter, r *http.Request) {
 
 	data, err := u.service.Login(req)
 	if err != nil {
+		u.gauge.UserHistory.With(prometheus.Labels{"code": "400", "method": "POST", "type": "login"}).Observe(time.Since(time.Now()).Seconds())
+
 		response := util.WriteJSON(util.BadRequest(err.Error()))
 		w.WriteHeader(400)
 		w.Write(response)
@@ -76,6 +92,9 @@ func(u *user) Login(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	u.gauge.UserHistory.With(prometheus.Labels{"code": "200", "method": "POST", "type": "login"}).Observe(time.Since(time.Now()).Seconds())
+	u.gauge.UserUpgrade.With(prometheus.Labels{"type": "login"}).Inc()
+
 	w.WriteHeader(200)
 	w.Write([]byte("sucess login"))
 	return
@@ -85,6 +104,8 @@ func(u *user) Update(w http.ResponseWriter, r *http.Request) {
 	var req domain.User
 	err := json.NewDecoder(r.Body).Decode(&req)
 	if err != nil {
+		u.gauge.UserHistory.With(prometheus.Labels{"code": "500", "method": "PUT", "type": "update"}).Observe(time.Since(time.Now()).Seconds())
+
 		response := util.WriteJSON(util.InternalServerError("cannot read request body"))
 		w.WriteHeader(500)
 		w.Write(response)
@@ -93,6 +114,8 @@ func(u *user) Update(w http.ResponseWriter, r *http.Request) {
 
 	id, err := middleware.GetUserID(r)
 	if err != nil {
+		u.gauge.UserHistory.With(prometheus.Labels{"code": "401", "method": "PUT", "type": "update"}).Observe(time.Since(time.Now()).Seconds())
+
 		response := util.WriteJSON(util.Unauthorized(err.Error()))
 		w.WriteHeader(401)
 		w.Write(response)
@@ -101,12 +124,18 @@ func(u *user) Update(w http.ResponseWriter, r *http.Request) {
 
 	err = u.service.Update(id, req)
 	if err != nil {
+		u.gauge.UserHistory.With(prometheus.Labels{"code": "400", "method": "PUT", "type": "update"}).Observe(time.Since(time.Now()).Seconds())
+
 		response := util.WriteJSON(util.BadRequest(err.Error()))
 		w.WriteHeader(400)
 		w.Write(response)
 		return
 	}
 
+
+	u.gauge.UserHistory.With(prometheus.Labels{"code": "200", "method": "PUT", "type": "update"}).Observe(time.Since(time.Now()).Seconds())
+	u.gauge.UserUpgrade.With(prometheus.Labels{"type": "update"}).Inc()
+
 	w.WriteHeader(200)
 	w.Write([]byte("success update user"))
 	return
diff --git a/internal/service/admin.go b/internal/service/admin.go
index 658dfaf..2ca2b5c 100644
--- a/internal/service/admin.go
+++ b/internal/service/admin.go
@@ -1,14 +1,10 @@
 package service
 
 import (
-	"time"
-
-	"github.com/prometheus/client_golang/prometheus"
 	"github.com/rulanugrh/larissa/internal/entity/domain"
 	"github.com/rulanugrh/larissa/internal/entity/web"
 	"github.com/rulanugrh/larissa/internal/repository"
 	"github.com/rulanugrh/larissa/internal/util"
-	"github.com/rulanugrh/larissa/pkg"
 )
 
 type AdminInterface interface {
@@ -26,16 +22,14 @@ type admin struct {
 	penyakit repository.PenyakitInterface
 	reported repository.ReportedInterface
 	user repository.UserInterface
-	gauge *pkg.Data
 }
 
-func NewAdmin(obat repository.ObatInterface, penyakit repository.PenyakitInterface, reported repository.ReportedInterface, user repository.UserInterface, gauge *pkg.Data) AdminInterface {
+func NewAdmin(obat repository.ObatInterface, penyakit repository.PenyakitInterface, reported repository.ReportedInterface, user repository.UserInterface) AdminInterface {
 	return &admin{
 		obat: obat,
 		penyakit: penyakit,
 		reported: reported,
 		user: user,
-		gauge: gauge,
 	}
 }
 
@@ -50,10 +44,6 @@ func(a *admin) CreatePenyakit(req domain.Penyakit) (*web.PenyakitCreated, error)
 		Name: data.Name,
 		Description: data.Description,
 	}
-
-	a.gauge.Penyakit.Inc()
-	a.gauge.PenyakitHistory.With(prometheus.Labels{"code": "200", "method": "POST", "type": "create"}).Observe(time.Since(time.Now()).Seconds())
-	a.gauge.PenyakitUpgrade.With(prometheus.Labels{"type": "create"}).Inc()
 	return &response, nil
 }
 
@@ -72,9 +62,7 @@ func(a *admin) CreateObat(req domain.Obat) (*web.ObatCreated, error) {
 		Name: data.Name,
 	}
 
-	a.gauge.Obat.Inc()
-	a.gauge.ObatHistory.With(prometheus.Labels{"code": "200", "method": "POST", "type": "create"}).Observe(time.Since(time.Now()).Seconds())
-	a.gauge.ObatUpgrade.With(prometheus.Labels{"type": "create"}).Inc()
+
 	return &response, nil
 }
 
@@ -93,8 +81,6 @@ func(a *admin) UpdateObat(id uint, req domain.Obat) (*web.ObatUpdated, error) {
 	}
 
 
-	a.gauge.ObatHistory.With(prometheus.Labels{"code": "200", "method": "PUT", "type": "update"}).Observe(time.Since(time.Now()).Seconds())
-	a.gauge.ObatUpgrade.With(prometheus.Labels{"type": "update"}).Inc()
 	return &response, nil
 }
 
@@ -104,8 +90,6 @@ func(a *admin) DeleteObat(id uint) error {
 		return util.Errors(err)
 	}
 
-	a.gauge.ObatHistory.With(prometheus.Labels{"code": "204", "method": "DELETE", "type": "delete"}).Observe(time.Since(time.Now()).Seconds())
-	a.gauge.ObatUpgrade.With(prometheus.Labels{"type": "delete"}).Inc()
 	return nil
 }
 
@@ -115,8 +99,6 @@ func(a *admin) DeletePenyakit(id uint) error {
 		return util.Errors(err)
 	}
 
-	a.gauge.PenyakitHistory.With(prometheus.Labels{"code": "204", "method": "DELETE", "type": "delete"}).Observe(time.Since(time.Now()).Seconds())
-	a.gauge.PenyakitUpgrade.With(prometheus.Labels{"type": "delete"}).Inc()
 	return nil
 }
 
@@ -138,8 +120,7 @@ func(a *admin) Reported() (*[]web.Reported, error) {
 		response = append(response, result)
 	}
 
-	a.gauge.KunjunganHistory.With(prometheus.Labels{"code": "200", "method": "GET", "type": "get"}).Observe(time.Since(time.Now()).Seconds())
-	a.gauge.Kunjungan.Set(float64(len(*data)))
+
 	return &response, nil
 }
 
@@ -163,8 +144,5 @@ func (a *admin) ListAllUser() (*[]web.User, error) {
 
 		response = append(response, result)
 	}
-
-	a.gauge.UserHistory.With(prometheus.Labels{"code": "200", "method": "GET", "type": "get"}).Observe(time.Since(time.Now()).Seconds())
-	a.gauge.User.Set(float64(len(*data)))
 	return &response, nil
 }
diff --git a/internal/service/kunjungan.go b/internal/service/kunjungan.go
index 69b3325..902b64c 100644
--- a/internal/service/kunjungan.go
+++ b/internal/service/kunjungan.go
@@ -1,15 +1,11 @@
 package service
 
 import (
-	"time"
-
-	"github.com/prometheus/client_golang/prometheus"
 	"github.com/rulanugrh/larissa/internal/entity/domain"
 	"github.com/rulanugrh/larissa/internal/entity/web"
 	"github.com/rulanugrh/larissa/internal/middleware"
 	"github.com/rulanugrh/larissa/internal/repository"
 	"github.com/rulanugrh/larissa/internal/util"
-	"github.com/rulanugrh/larissa/pkg"
 )
 
 type KunjunganInterface interface {
@@ -21,15 +17,13 @@ type kunjungan struct {
 	krepo repository.KunjunganInterface
 	reported repository.ReportedInterface
 	validate middleware.IValidation
-	gauge pkg.Data
 }
 
-func NewKunjungan(krepo repository.KunjunganInterface, reported repository.ReportedInterface, gauge pkg.Data) KunjunganInterface {
+func NewKunjungan(krepo repository.KunjunganInterface, reported repository.ReportedInterface) KunjunganInterface {
 	return &kunjungan{
 		krepo: krepo,
 		reported: reported,
 		validate: middleware.NewValidation(),
-		gauge: gauge,
 	}
 }
 
@@ -83,10 +77,6 @@ func(k *kunjungan) Create(req domain.Kunjungan) (*web.Kunjungan, error) {
 		Penyakit: penyakit,
 	}
 
-
-	k.gauge.Kunjungan.Inc()
-	k.gauge.KunjunganHistory.With(prometheus.Labels{"code": "200", "method": "POST", "type": "create"}).Observe(time.Since(time.Now()).Seconds())
-	k.gauge.KunjunganUpgrade.With(prometheus.Labels{"type": "create"}).Inc()
 	return &response, nil
 }
 
diff --git a/internal/service/obat.go b/internal/service/obat.go
index fc7abe7..258c908 100644
--- a/internal/service/obat.go
+++ b/internal/service/obat.go
@@ -1,13 +1,9 @@
 package service
 
 import (
-	"time"
-
-	"github.com/prometheus/client_golang/prometheus"
 	"github.com/rulanugrh/larissa/internal/entity/web"
 	"github.com/rulanugrh/larissa/internal/repository"
 	"github.com/rulanugrh/larissa/internal/util"
-	"github.com/rulanugrh/larissa/pkg"
 )
 
 type ObatInterface interface {
@@ -17,13 +13,11 @@ type ObatInterface interface {
 
 type obat struct {
 	orepo  repository.ObatInterface
-	metric pkg.Data
 }
 
-func NewObat(orepo repository.ObatInterface, metric pkg.Data) ObatInterface {
+func NewObat(orepo repository.ObatInterface) ObatInterface {
 	return &obat{
 		orepo: orepo,
-		metric: metric,
 	}
 }
 
@@ -65,8 +59,5 @@ func(o *obat) FindAll() (*[]web.Obat, error)  {
 		response = append(response, result)
 	}
 
-	o.metric.ObatHistory.With(prometheus.Labels{"code": "200", "method": "GET", "type": "get"}).Observe(time.Since(time.Now()).Seconds())
-	o.metric.Obat.Set(float64(len(*data)))
-
 	return &response, nil
 }
diff --git a/internal/service/penyakit.go b/internal/service/penyakit.go
index 8f797a6..e50e20b 100644
--- a/internal/service/penyakit.go
+++ b/internal/service/penyakit.go
@@ -1,13 +1,9 @@
 package service
 
 import (
-	"time"
-
-	"github.com/prometheus/client_golang/prometheus"
 	"github.com/rulanugrh/larissa/internal/entity/web"
 	"github.com/rulanugrh/larissa/internal/repository"
 	"github.com/rulanugrh/larissa/internal/util"
-	"github.com/rulanugrh/larissa/pkg"
 )
 
 type PenyakitInterface interface {
@@ -17,13 +13,11 @@ type PenyakitInterface interface {
 
 type penyakit struct {
 	repository repository.PenyakitInterface
-	gauge pkg.Data
 }
 
-func NewPenyakit(repository repository.PenyakitInterface, gauge pkg.Data) PenyakitInterface {
+func NewPenyakit(repository repository.PenyakitInterface) PenyakitInterface {
 	return &penyakit{
 		repository: repository,
-		gauge: gauge,
 	}
 }
 
@@ -89,8 +83,5 @@ func (p *penyakit) FindAll() (*[]web.Penyakit, error) {
 		response = append(response, result)
 	}
 
-	p.gauge.PenyakitHistory.With(prometheus.Labels{"code": "200", "method": "GET", "type": "get"}).Observe(time.Since(time.Now()).Seconds())
-	p.gauge.Penyakit.Set(float64(len(*data)))
-
 	return &response, nil
 }
diff --git a/internal/service/user.go b/internal/service/user.go
index 408051e..502e558 100644
--- a/internal/service/user.go
+++ b/internal/service/user.go
@@ -1,15 +1,11 @@
 package service
 
 import (
-	"time"
-
-	"github.com/prometheus/client_golang/prometheus"
 	"github.com/rulanugrh/larissa/internal/entity/domain"
 	"github.com/rulanugrh/larissa/internal/entity/web"
 	"github.com/rulanugrh/larissa/internal/middleware"
 	"github.com/rulanugrh/larissa/internal/repository"
 	"github.com/rulanugrh/larissa/internal/util"
-	"github.com/rulanugrh/larissa/pkg"
 	"golang.org/x/crypto/bcrypt"
 )
 
@@ -22,14 +18,12 @@ type UserInterface interface {
 type user struct {
 	urepo repository.UserInterface
 	validate middleware.IValidation
-	gauge pkg.Data
 }
 
-func NewUser(urepo repository.UserInterface, gauge pkg.Data) UserInterface {
+func NewUser(urepo repository.UserInterface) UserInterface {
 	return &user{
 		urepo: urepo,
 		validate: middleware.NewValidation(),
-		gauge: gauge,
 	}
 }
 
@@ -69,9 +63,7 @@ func(u *user) Register(req domain.UserRegister) (*web.User, error) {
 		TTL: data.TTL,
 	}
 
-	u.gauge.User.Inc()
-	u.gauge.UserHistory.With(prometheus.Labels{"code": "200", "method": "POST", "type": "update"}).Observe(time.Since(time.Now()).Seconds())
-	u.gauge.UserUpgrade.With(prometheus.Labels{"type": "create"}).Inc()
+
 	return &response, nil
 }
 
@@ -95,8 +87,7 @@ func(u *user) Login(req domain.UserLogin) (*string, error) {
 	if err != nil {
 		return nil, err
 	}
-	u.gauge.UserHistory.With(prometheus.Labels{"code": "200", "method": "POST", "type": "login"}).Observe(time.Since(time.Now()).Seconds())
-	u.gauge.UserUpgrade.With(prometheus.Labels{"type": "login"}).Inc()
+
 	return &token, nil
 }
 
@@ -107,7 +98,5 @@ func(u *user) Update(id uint, req domain.User) error {
 		return util.Errors(err)
 	}
 
-	u.gauge.UserHistory.With(prometheus.Labels{"code": "200", "method": "PUT", "type": "update"}).Observe(time.Since(time.Now()).Seconds())
-	u.gauge.UserUpgrade.With(prometheus.Labels{"type": "update"}).Inc()
 	return nil
 }