diff --git a/core/prof/profilecenter.go b/core/prof/profilecenter.go
index 81ee704c..17f1b356 100644
--- a/core/prof/profilecenter.go
+++ b/core/prof/profilecenter.go
@@ -13,34 +13,34 @@ import (
 )
 
 type (
-	Slot struct {
+	profileSlot struct {
 		lifecount int64
 		lastcount int64
 		lifecycle int64
 		lastcycle int64
 	}
 
-	ProfileCenter struct {
+	profileCenter struct {
 		lock  sync.RWMutex
-		slots map[string]*Slot
+		slots map[string]*profileSlot
 	}
 )
 
 const flushInterval = 5 * time.Minute
 
 var (
-	profileCenter = &ProfileCenter{
-		slots: make(map[string]*Slot),
+	pc = &profileCenter{
+		slots: make(map[string]*profileSlot),
 	}
 	once sync.Once
 )
 
 func report(name string, duration time.Duration) {
 	updated := func() bool {
-		profileCenter.lock.RLock()
-		defer profileCenter.lock.RUnlock()
+		pc.lock.RLock()
+		defer pc.lock.RUnlock()
 
-		slot, ok := profileCenter.slots[name]
+		slot, ok := pc.slots[name]
 		if ok {
 			atomic.AddInt64(&slot.lifecount, 1)
 			atomic.AddInt64(&slot.lastcount, 1)
@@ -52,10 +52,10 @@ func report(name string, duration time.Duration) {
 
 	if !updated {
 		func() {
-			profileCenter.lock.Lock()
-			defer profileCenter.lock.Unlock()
+			pc.lock.Lock()
+			defer pc.lock.Unlock()
 
-			profileCenter.slots[name] = &Slot{
+			pc.slots[name] = &profileSlot{
 				lifecount: 1,
 				lastcount: 1,
 				lifecycle: int64(duration),
@@ -89,10 +89,10 @@ func generateReport() string {
 	}
 
 	func() {
-		profileCenter.lock.Lock()
-		defer profileCenter.lock.Unlock()
+		pc.lock.Lock()
+		defer pc.lock.Unlock()
 
-		for key, slot := range profileCenter.slots {
+		for key, slot := range pc.slots {
 			data = append(data, []string{
 				key,
 				strconv.FormatInt(slot.lifecount, 10),
diff --git a/core/prof/profiler.go b/core/prof/profiler.go
index 03ba57b1..37795dd1 100644
--- a/core/prof/profiler.go
+++ b/core/prof/profiler.go
@@ -3,56 +3,61 @@ package prof
 import "github.com/tal-tech/go-zero/core/utils"
 
 type (
+	// A ProfilePoint is a profile time point.
 	ProfilePoint struct {
 		*utils.ElapsedTimer
 	}
 
+	// A Profiler interface represents a profiler that used to report profile points.
 	Profiler interface {
 		Start() ProfilePoint
 		Report(name string, point ProfilePoint)
 	}
 
-	RealProfiler struct{}
+	realProfiler struct{}
 
-	NullProfiler struct{}
+	nullProfiler struct{}
 )
 
 var profiler = newNullProfiler()
 
+// EnableProfiling enables profiling.
 func EnableProfiling() {
 	profiler = newRealProfiler()
 }
 
+// Start starts a Profiler, and returns a start profiling point.
 func Start() ProfilePoint {
 	return profiler.Start()
 }
 
+// Report reports a ProfilePoint with given name.
 func Report(name string, point ProfilePoint) {
 	profiler.Report(name, point)
 }
 
 func newRealProfiler() Profiler {
-	return &RealProfiler{}
+	return &realProfiler{}
 }
 
-func (rp *RealProfiler) Start() ProfilePoint {
+func (rp *realProfiler) Start() ProfilePoint {
 	return ProfilePoint{
 		ElapsedTimer: utils.NewElapsedTimer(),
 	}
 }
 
-func (rp *RealProfiler) Report(name string, point ProfilePoint) {
+func (rp *realProfiler) Report(name string, point ProfilePoint) {
 	duration := point.Duration()
 	report(name, duration)
 }
 
 func newNullProfiler() Profiler {
-	return &NullProfiler{}
+	return &nullProfiler{}
 }
 
-func (np *NullProfiler) Start() ProfilePoint {
+func (np *nullProfiler) Start() ProfilePoint {
 	return ProfilePoint{}
 }
 
-func (np *NullProfiler) Report(string, ProfilePoint) {
+func (np *nullProfiler) Report(string, ProfilePoint) {
 }