完善 report 机制

Author: FishGoddess

_examples/report.go

@@ -40,20 +40,16 @@ func reportLoad(reporter *cachego.Reporter, key string, value interface{}, ttl t
 }
 
 func main() {
-	// Create a cache as usual.
-	cache := cachego.NewCache(
-		cachego.WithMaxEntries(3),
-		cachego.WithGC(100*time.Millisecond),
-	)
-
-	// Use Report function to wrap a cache with reporting logics.
 	// We provide some reporting points for monitor cache.
 	// ReportMissed reports the missed key getting from cache.
 	// ReportHit reports the hit entry getting from cache.
 	// ReportGC reports the status of cache gc.
 	// ReportLoad reports the result of loading.
-	cache, reporter := cachego.Report(
-		cache,
+	// Use NewCacheWithReport to create a cache with report.
+	cache, reporter := cachego.NewCacheWithReport(
+		cachego.WithMaxEntries(3),
+		cachego.WithGC(100*time.Millisecond),
+
 		cachego.WithReportMissed(reportMissed),
 		cachego.WithReportHit(reportHit),
 		cachego.WithReportGC(reportGC),

cache.go

@@ -116,12 +116,7 @@ func RunGCTask(cache Cache, duration time.Duration) (cancel func()) {
 	return cancel
 }
 
-// NewCache creates a cache with options.
-// By default, it will create a standard cache which uses one lock to solve data race.
-// It may cause a big performance problem in high concurrency.
-// You can use WithShardings to create a sharding cache which is good for concurrency.
-// Also, you can use options to specify the type of cache to others, such as lru.
-func NewCache(opts ...Option) (cache Cache) {
+func newCache(withReport bool, opts ...Option) (cache Cache, reporter *Reporter) {
 	conf := newDefaultConfig()
 	applyOptions(conf, opts)
 
@@ -136,9 +131,33 @@ func NewCache(opts ...Option) (cache Cache) {
 		cache = newCache(conf)
 	}
 
+	if withReport {
+		cache, reporter = report(conf, cache)
+	}
+
 	if conf.gcDuration > 0 {
 		RunGCTask(cache, conf.gcDuration)
 	}
 
+	return cache, reporter
+}
+
+// NewCache creates a cache with options.
+// By default, it will create a standard cache which uses one lock to solve data race.
+// It may cause a big performance problem in high concurrency.
+// You can use WithShardings to create a sharding cache which is good for concurrency.
+// Also, you can use options to specify the type of cache to others, such as lru.
+// Use NewCacheWithReporter to get a reporter for use if you want.
+func NewCache(opts ...Option) (cache Cache) {
+	cache, _ = newCache(false, opts...)
 	return cache
 }
+
+// NewCacheWithReport creates a cache and a reporter with options.
+// By default, it will create a standard cache which uses one lock to solve data race.
+// It may cause a big performance problem in high concurrency.
+// You can use WithShardings to create a sharding cache which is good for concurrency.
+// Also, you can use options to specify the type of cache to others, such as lru.
+func NewCacheWithReport(opts ...Option) (cache Cache, reporter *Reporter) {
+	return newCache(true, opts...)
+}

cache_test.go

@@ -246,8 +246,8 @@ func testCacheImplement(t *testing.T, cache Cache) {
 	}
 }
 
-// go test -v -cover=^TestNew$
-func TestNew(t *testing.T) {
+// go test -v -cover=^TestNewCache$
+func TestNewCache(t *testing.T) {
 	cache := NewCache()
 
 	sc1, ok := cache.(*standardCache)
@@ -290,6 +290,24 @@ func TestNew(t *testing.T) {
 	cache = NewCache(WithLRU(0))
 }
 
+// go test -v -cover=^TestNewCacheWithReport$
+func TestNewCacheWithReport(t *testing.T) {
+	cache, reporter := NewCacheWithReport()
+
+	sc1, ok := cache.(*reportableCache)
+	if !ok {
+		t.Errorf("cache.(*reportableCache) %T not ok", cache)
+	}
+
+	if sc1 == nil {
+		t.Error("sc1 == nil")
+	}
+
+	if reporter == nil {
+		t.Error("reporter == nil")
+	}
+}
+
 // go test -v -cover=^TestRunGCTask$
 func TestRunGCTask(t *testing.T) {
 	cache := new(testCache)

config.go

@@ -27,23 +27,6 @@ type config struct {
 
 	now  func() int64
 	hash func(key string) int
-}
-
-func newDefaultConfig() *config {
-	return &config{
-		cacheType:    standard,
-		shardings:    0,
-		singleflight: true,
-		gcDuration:   0,
-		maxScans:     10000,
-		maxEntries:   0,
-		now:          now,
-		hash:         hash,
-	}
-}
-
-type reportConfig struct {
-	now func() int64
 
 	recordMissed bool
 	recordHit    bool
@@ -56,16 +39,19 @@ type reportConfig struct {
 	reportLoad   func(reporter *Reporter, key string, value interface{}, ttl time.Duration, err error)
 }
 
-func newDefaultReportConfig() *reportConfig {
-	return &reportConfig{
+func newDefaultConfig() *config {
+	return &config{
+		cacheType:    standard,
+		shardings:    0,
+		singleflight: true,
+		gcDuration:   0,
+		maxScans:     10000,
+		maxEntries:   0,
 		now:          now,
+		hash:         hash,
 		recordMissed: true,
 		recordHit:    true,
 		recordGC:     true,
 		recordLoad:   true,
-		reportMissed: nil,
-		reportHit:    nil,
-		reportGC:     nil,
-		reportLoad:   nil,
 	}
 }

config_test.go

@@ -52,14 +52,6 @@ func isConfigEquals(conf1 *config, conf2 *config) bool {
 		return false
 	}
 
-	return true
-}
-
-func isReportConfigEquals(conf1 *reportConfig, conf2 *reportConfig) bool {
-	if fmt.Sprintf("%p", conf1.now) != fmt.Sprintf("%p", conf2.now) {
-		return false
-	}
-
 	if conf1.recordMissed != conf2.recordMissed {
 		return false
 	}
@@ -72,6 +64,10 @@ func isReportConfigEquals(conf1 *reportConfig, conf2 *reportConfig) bool {
 		return false
 	}
 
+	if conf1.recordLoad != conf2.recordLoad {
+		return false
+	}
+
 	if fmt.Sprintf("%p", conf1.reportMissed) != fmt.Sprintf("%p", conf2.reportMissed) {
 		return false
 	}
@@ -99,6 +95,10 @@ func TestApplyOptions(t *testing.T) {
 		gcDuration:   0,
 		maxScans:     0,
 		maxEntries:   0,
+		recordMissed: false,
+		recordHit:    false,
+		recordGC:     false,
+		recordLoad:   false,
 	}
 
 	expect := &config{
@@ -107,6 +107,10 @@ func TestApplyOptions(t *testing.T) {
 		gcDuration:   2,
 		maxScans:     3,
 		maxEntries:   4,
+		recordMissed: true,
+		recordHit:    true,
+		recordGC:     true,
+		recordLoad:   true,
 	}
 
 	applyOptions(got, []Option{
@@ -115,45 +119,13 @@ func TestApplyOptions(t *testing.T) {
 		WithGC(2),
 		WithMaxScans(3),
 		WithMaxEntries(4),
-	})
-
-	if !isConfigEquals(got, expect) {
-		t.Errorf("got %+v != expect %+v", got, expect)
-	}
-}
-
-// go test -v -cover -run=^TestApplyReportOptions$
-func TestApplyReportOptions(t *testing.T) {
-	reportHit := func(reporter *Reporter, key string, value interface{}) {}
-
-	got := &reportConfig{
-		now:          nil,
-		recordMissed: false,
-		recordHit:    false,
-		recordGC:     false,
-		recordLoad:   false,
-		reportHit:    nil,
-	}
-
-	expect := &reportConfig{
-		now:          now,
-		recordMissed: true,
-		recordHit:    true,
-		recordGC:     true,
-		recordLoad:   true,
-		reportHit:    reportHit,
-	}
-
-	applyReportOptions(got, []ReportOption{
-		WithReporterNow(now),
 		WithRecordMissed(true),
 		WithRecordHit(true),
 		WithRecordGC(true),
 		WithRecordLoad(true),
-		WithReportHit(reportHit),
 	})
 
-	if !isReportConfigEquals(got, expect) {
+	if !isConfigEquals(got, expect) {
 		t.Errorf("got %+v != expect %+v", got, expect)
 	}
 }

doc.go

@@ -330,36 +330,32 @@ Package cachego provides an easy way to use foundation for your caching operatio
 
 8. report:
 
-	func reportMissed(key string) {
-		fmt.Printf("report: missed key %s\n", key)
+	func reportMissed(reporter *cachego.Reporter, key string) {
+		fmt.Printf("report: missed key %s, missed rate %.3f\n", key, reporter.MissedRate())
 	}
 
-	func reportHit(key string, value interface{}) {
-		fmt.Printf("report: hit key %s value %+v\n", key, value)
+	func reportHit(reporter *cachego.Reporter, key string, value interface{}) {
+		fmt.Printf("report: hit key %s value %+v, hit rate %.3f\n", key, value, reporter.HitRate())
 	}
 
-	func reportGC(cost time.Duration, cleans int) {
-		fmt.Printf("report: gc cost %s cleans %d\n", cost, cleans)
+	func reportGC(reporter *cachego.Reporter, cost time.Duration, cleans int) {
+		fmt.Printf("report: gc cost %s cleans %d, gc count %d, cache size %d\n", cost, cleans, reporter.CountGC(), reporter.CacheSize())
 	}
 
-	func reportLoad(key string, value interface{}, ttl time.Duration, err error) {
-		fmt.Printf("report: load key %s value %+v ttl %s, err %+v\n", key, value, ttl, err)
+	func reportLoad(reporter *cachego.Reporter, key string, value interface{}, ttl time.Duration, err error) {
+		fmt.Printf("report: load key %s value %+v ttl %s, err %+v, load count %d\n", key, value, ttl, err, reporter.CountLoad())
 	}
 
-	// Create a cache as usual.
-	cache := cachego.NewCache(
-		cachego.WithMaxEntries(3),
-		cachego.WithGC(100*time.Millisecond),
-	)
-
-	// Use Report function to wrap a cache with reporting logics.
 	// We provide some reporting points for monitor cache.
 	// ReportMissed reports the missed key getting from cache.
 	// ReportHit reports the hit entry getting from cache.
 	// ReportGC reports the status of cache gc.
 	// ReportLoad reports the result of loading.
-	cache, reporter := cachego.Report(
-		cache,
+	// Use NewCacheWithReport to create a cache with report.
+	cache, reporter := cachego.NewCacheWithReport(
+		cachego.WithMaxEntries(3),
+		cachego.WithGC(100*time.Millisecond),
+
 		cachego.WithReportMissed(reportMissed),
 		cachego.WithReportHit(reportHit),
 		cachego.WithReportGC(reportGC),
@@ -390,6 +386,7 @@ Package cachego provides an easy way to use foundation for your caching operatio
 	fmt.Println("CountMissed:", reporter.CountMissed())
 	fmt.Println("CountHit:", reporter.CountHit())
 	fmt.Println("CountGC:", reporter.CountGC())
+	fmt.Println("CountLoad:", reporter.CountLoad())
 	fmt.Println("CacheSize:", reporter.CacheSize())
 	fmt.Println("MissedRate:", reporter.MissedRate())
 	fmt.Println("HitRate:", reporter.HitRate())
@@ -454,4 +451,4 @@ Package cachego provides an easy way to use foundation for your caching operatio
 package cachego // import "github.com/FishGoddess/cachego"
 
 // Version is the version string representation of cachego.
-const Version = "v0.4.4-alpha"
+const Version = "v0.4.5-alpha"