How to use reporter method of reporter Package

...16	"github.com/hyperledger/fabric/common/flogging"17	"github.com/prometheus/client_golang/prometheus"18	"github.com/prometheus/client_golang/prometheus/promhttp"19	"github.com/uber-go/tally"20	promreporter "github.com/uber-go/tally/prometheus"21	statsdreporter "github.com/uber-go/tally/statsd"22)23var logger = flogging.MustGetLogger("common/metrics/tally")24var scopeRegistryKey = tally.KeyForPrefixedStringMap25type counter struct {26	tallyCounter tally.Counter27}28func newCounter(tallyCounter tally.Counter) *counter {29	return &counter{tallyCounter: tallyCounter}30}31func (c *counter) Inc(v int64) {32	c.tallyCounter.Inc(v)33}34type gauge struct {35	tallyGauge tally.Gauge36}37func newGauge(tallyGauge tally.Gauge) *gauge {38	return &gauge{tallyGauge: tallyGauge}39}40func (g *gauge) Update(v float64) {41	g.tallyGauge.Update(v)42}43type scopeRegistry struct {44	sync.RWMutex45	subScopes map[string]*scope46}47type scope struct {48	separator    string49	prefix       string50	tags         map[string]string51	tallyScope   tally.Scope52	registry     *scopeRegistry53	baseReporter tally.BaseStatsReporter54	cm sync.RWMutex55	gm sync.RWMutex56	counters map[string]*counter57	gauges   map[string]*gauge58}59func newRootScope(opts tally.ScopeOptions, interval time.Duration) Scope {60	s, _ := tally.NewRootScope(opts, interval)61	var baseReporter tally.BaseStatsReporter62	if opts.Reporter != nil {63		baseReporter = opts.Reporter64	} else if opts.CachedReporter != nil {65		baseReporter = opts.CachedReporter66	}67	return &scope{68		prefix:     opts.Prefix,69		separator:  opts.Separator,70		tallyScope: s,71		registry: &scopeRegistry{72			subScopes: make(map[string]*scope),73		},74		baseReporter: baseReporter,75		counters:     make(map[string]*counter),76		gauges:       make(map[string]*gauge)}77}78func newStatsdReporter(statsdReporterOpts StatsdReporterOpts) (tally.StatsReporter, error) {79	if statsdReporterOpts.Address == "" {80		return nil, errors.New("missing statsd server Address option")81	}82	if statsdReporterOpts.FlushInterval <= 0 {83		return nil, errors.New("missing statsd FlushInterval option")84	}85	if statsdReporterOpts.FlushBytes <= 0 {86		return nil, errors.New("missing statsd FlushBytes option")87	}88	statter, err := statsd.NewBufferedClient(statsdReporterOpts.Address,89		"", statsdReporterOpts.FlushInterval, statsdReporterOpts.FlushBytes)90	if err != nil {91		return nil, err92	}93	opts := statsdreporter.Options{}94	reporter := statsdreporter.NewReporter(statter, opts)95	statsdReporter := &statsdReporter{reporter: reporter, statter: statter}96	return statsdReporter, nil97}98func newPromReporter(promReporterOpts PromReporterOpts) (promreporter.Reporter, error) {99	if promReporterOpts.ListenAddress == "" {100		return nil, errors.New("missing prometheus listenAddress option")101	}102	opts := promreporter.Options{Registerer: prometheus.NewRegistry()}103	reporter := promreporter.NewReporter(opts)104	mux := http.NewServeMux()105	handler := promReporterHttpHandler(opts.Registerer.(*prometheus.Registry))106	mux.Handle("/metrics", handler)107	server := &http.Server{Addr: promReporterOpts.ListenAddress, Handler: mux}108	promReporter := &promReporter{109		reporter: reporter,110		server:   server,111		registry: opts.Registerer.(*prometheus.Registry)}112	return promReporter, nil113}114func (s *scope) Counter(name string) Counter {115	s.cm.RLock()116	val, ok := s.counters[name]117	s.cm.RUnlock()118	if !ok {119		s.cm.Lock()120		val, ok = s.counters[name]121		if !ok {122			counter := s.tallyScope.Counter(name)123			val = newCounter(counter)124			s.counters[name] = val125		}126		s.cm.Unlock()127	}128	return val129}130func (s *scope) Gauge(name string) Gauge {131	s.gm.RLock()132	val, ok := s.gauges[name]133	s.gm.RUnlock()134	if !ok {135		s.gm.Lock()136		val, ok = s.gauges[name]137		if !ok {138			gauge := s.tallyScope.Gauge(name)139			val = newGauge(gauge)140			s.gauges[name] = val141		}142		s.gm.Unlock()143	}144	return val145}146func (s *scope) Tagged(tags map[string]string) Scope {147	originTags := tags148	tags = mergeRightTags(s.tags, tags)149	key := scopeRegistryKey(s.prefix, tags)150	s.registry.RLock()151	existing, ok := s.registry.subScopes[key]152	if ok {153		s.registry.RUnlock()154		return existing155	}156	s.registry.RUnlock()157	s.registry.Lock()158	defer s.registry.Unlock()159	existing, ok = s.registry.subScopes[key]160	if ok {161		return existing162	}163	subScope := &scope{164		separator: s.separator,165		prefix:    s.prefix,166		// NB(r): Take a copy of the tags on creation167		// so that it cannot be modified after set.168		tags:       copyStringMap(tags),169		tallyScope: s.tallyScope.Tagged(originTags),170		registry:   s.registry,171		counters: make(map[string]*counter),172		gauges:   make(map[string]*gauge),173	}174	s.registry.subScopes[key] = subScope175	return subScope176}177func (s *scope) SubScope(prefix string) Scope {178	key := scopeRegistryKey(s.fullyQualifiedName(prefix), s.tags)179	s.registry.RLock()180	existing, ok := s.registry.subScopes[key]181	if ok {182		s.registry.RUnlock()183		return existing184	}185	s.registry.RUnlock()186	s.registry.Lock()187	defer s.registry.Unlock()188	existing, ok = s.registry.subScopes[key]189	if ok {190		return existing191	}192	subScope := &scope{193		separator: s.separator,194		prefix:    s.prefix,195		// NB(r): Take a copy of the tags on creation196		// so that it cannot be modified after set.197		tags:       copyStringMap(s.tags),198		tallyScope: s.tallyScope.SubScope(prefix),199		registry:   s.registry,200		counters: make(map[string]*counter),201		gauges:   make(map[string]*gauge),202	}203	s.registry.subScopes[key] = subScope204	return subScope205}206func (s *scope) Close() error {207	if closer, ok := s.tallyScope.(io.Closer); ok {208		return closer.Close()209	}210	return nil211}212func (s *scope) Start() error {213	if server, ok := s.baseReporter.(serve); ok {214		return server.Start()215	}216	return nil217}218type statsdReporter struct {219	reporter tally.StatsReporter220	statter  statsd.Statter221}222type promReporter struct {223	reporter promreporter.Reporter224	server   *http.Server225	registry *prometheus.Registry226}227func (r *statsdReporter) ReportCounter(name string, tags map[string]string, value int64) {228	r.reporter.ReportCounter(tagsToName(name, tags), tags, value)229}230func (r *statsdReporter) ReportGauge(name string, tags map[string]string, value float64) {231	r.reporter.ReportGauge(tagsToName(name, tags), tags, value)232}233func (r *statsdReporter) ReportTimer(name string, tags map[string]string, interval time.Duration) {234	r.reporter.ReportTimer(tagsToName(name, tags), tags, interval)235}236func (r *statsdReporter) ReportHistogramValueSamples(237	name string,238	tags map[string]string,239	buckets tally.Buckets,240	bucketLowerBound,241	bucketUpperBound float64,242	samples int64,243) {244	r.reporter.ReportHistogramValueSamples(tagsToName(name, tags), tags, buckets, bucketLowerBound, bucketUpperBound, samples)245}246func (r *statsdReporter) ReportHistogramDurationSamples(247	name string,248	tags map[string]string,249	buckets tally.Buckets,250	bucketLowerBound,251	bucketUpperBound time.Duration,252	samples int64,253) {254	r.reporter.ReportHistogramDurationSamples(tagsToName(name, tags), tags, buckets, bucketLowerBound, bucketUpperBound, samples)255}256func (r *statsdReporter) Capabilities() tally.Capabilities {257	return r258}259func (r *statsdReporter) Reporting() bool {260	return true261}262func (r *statsdReporter) Tagging() bool {263	return true264}265func (r *statsdReporter) Flush() {266	// no-op267}268func (r *statsdReporter) Close() error {269	return r.statter.Close()270}271func (r *promReporter) RegisterCounter(272	name string,273	tagKeys []string,274	desc string,275) (*prometheus.CounterVec, error) {276	return r.reporter.RegisterCounter(name, tagKeys, desc)277}278// AllocateCounter implements tally.CachedStatsReporter.279func (r *promReporter) AllocateCounter(name string, tags map[string]string) tally.CachedCount {280	return r.reporter.AllocateCounter(name, tags)281}282func (r *promReporter) RegisterGauge(283	name string,284	tagKeys []string,285	desc string,286) (*prometheus.GaugeVec, error) {287	return r.reporter.RegisterGauge(name, tagKeys, desc)288}289// AllocateGauge implements tally.CachedStatsReporter.290func (r *promReporter) AllocateGauge(name string, tags map[string]string) tally.CachedGauge {291	return r.reporter.AllocateGauge(name, tags)292}293func (r *promReporter) RegisterTimer(294	name string,295	tagKeys []string,296	desc string,297	opts *promreporter.RegisterTimerOptions,298) (promreporter.TimerUnion, error) {299	return r.reporter.RegisterTimer(name, tagKeys, desc, opts)300}301// AllocateTimer implements tally.CachedStatsReporter.302func (r *promReporter) AllocateTimer(name string, tags map[string]string) tally.CachedTimer {303	return r.reporter.AllocateTimer(name, tags)304}305func (r *promReporter) AllocateHistogram(306	name string,307	tags map[string]string,308	buckets tally.Buckets,309) tally.CachedHistogram {310	return r.reporter.AllocateHistogram(name, tags, buckets)311}312func (r *promReporter) Capabilities() tally.Capabilities {313	return r314}315func (r *promReporter) Reporting() bool {316	return true317}318func (r *promReporter) Tagging() bool {319	return true320}321// Flush does nothing for prometheus322func (r *promReporter) Flush() {323}324func (r *promReporter) Close() error {...

...26// NewOpts create metrics options based config file27func NewOpts() Opts {28	opts := Opts{}29	opts.Enabled = viper.GetBool("metrics.enabled")30	if report := viper.GetString("metrics.reporter"); report != "" {31		opts.Reporter = report32	} else {33		opts.Reporter = defaultReporterType34	}35	if interval := viper.GetDuration("metrics.interval"); interval > 0 {36		opts.Interval = interval37	} else {38		opts.Interval = defaultInterval39	}40	if opts.Reporter == statsdReporterType {41		statsdOpts := StatsdReporterOpts{}42		statsdOpts.Address = viper.GetString("metrics.statsdReporter.address")43		if flushInterval := viper.GetDuration("metrics.statsdReporter.flushInterval"); flushInterval > 0 {44			statsdOpts.FlushInterval = flushInterval45		} else {46			statsdOpts.FlushInterval = defaultStatsdReporterFlushInterval47		}48		if flushBytes := viper.GetInt("metrics.statsdReporter.flushBytes"); flushBytes > 0 {49			statsdOpts.FlushBytes = flushBytes50		} else {51			statsdOpts.FlushBytes = defaultStatsdReporterFlushBytes52		}53		opts.StatsdReporterOpts = statsdOpts54	}55	if opts.Reporter == promReporterType {56		promOpts := PromReporterOpts{}57		promOpts.ListenAddress = viper.GetString("metrics.promReporter.listenAddress")58		opts.PromReporterOpts = promOpts59	}60	return opts61}62//Init initializes global root metrics scope instance, all callers can only use it to extend sub scope63func Init(opts Opts) (err error) {64	once.Do(func() {65		RootScope, err = create(opts)66	})67	return68}69//Start starts metrics server70func Start() error {71	rootScopeMutex.Lock()72	defer rootScopeMutex.Unlock()73	if running {74		return nil75	}76	running = true77	return RootScope.Start()78}79//Shutdown closes underlying resources used by metrics server80func Shutdown() error {81	rootScopeMutex.Lock()82	defer rootScopeMutex.Unlock()83	if !running {84		return nil85	}86	err := RootScope.Close()87	RootScope = nil88	running = false89	return err90}91func isRunning() bool {92	rootScopeMutex.Lock()93	defer rootScopeMutex.Unlock()94	return running95}96type StatsdReporterOpts struct {97	Address       string98	FlushInterval time.Duration99	FlushBytes    int100}101type PromReporterOpts struct {102	ListenAddress string103}104type Opts struct {105	Reporter           string106	Interval           time.Duration107	Enabled            bool108	StatsdReporterOpts StatsdReporterOpts109	PromReporterOpts   PromReporterOpts110}111type noOpCounter struct {112}113func (c *noOpCounter) Inc(v int64) {114}115type noOpGauge struct {116}117func (g *noOpGauge) Update(v float64) {118}119type noOpScope struct {120	counter *noOpCounter121	gauge   *noOpGauge122}123func (s *noOpScope) Counter(name string) Counter {124	return s.counter125}126func (s *noOpScope) Gauge(name string) Gauge {127	return s.gauge128}129func (s *noOpScope) Tagged(tags map[string]string) Scope {130	return s131}132func (s *noOpScope) SubScope(prefix string) Scope {133	return s134}135func (s *noOpScope) Close() error {136	return nil137}138func (s *noOpScope) Start() error {139	return nil140}141func newNoOpScope() Scope {142	return &noOpScope{143		counter: &noOpCounter{},144		gauge:   &noOpGauge{},145	}146}147func create(opts Opts) (rootScope Scope, e error) {148	if !opts.Enabled {149		rootScope = newNoOpScope()150		return151	} else {152		if opts.Interval <= 0 {153			e = fmt.Errorf("invalid Interval option %d", opts.Interval)154			return155		}156		if opts.Reporter != statsdReporterType && opts.Reporter != promReporterType {157			e = fmt.Errorf("not supported Reporter type %s", opts.Reporter)158			return159		}160		var reporter tally.StatsReporter161		var cachedReporter tally.CachedStatsReporter162		if opts.Reporter == statsdReporterType {163			reporter, e = newStatsdReporter(opts.StatsdReporterOpts)164		}165		if opts.Reporter == promReporterType {166			cachedReporter, e = newPromReporter(opts.PromReporterOpts)167		}168		if e != nil {169			return170		}171		rootScope = newRootScope(172			tally.ScopeOptions{173				Prefix:         namespace,174				Reporter:       reporter,175				CachedReporter: cachedReporter,176			}, opts.Interval)177		return178	}179}...

1import (2func main() {3	fmt.Println(reporter.Reporter())4}5import (6func main() {7	fmt.Println(reporter.Reporter())8}9import (10func main() {11	fmt.Println(reporter.Reporter())12}13import (14func main() {15	fmt.Println(reporter.Reporter())16}17import (18func main() {19	fmt.Println(reporter.Reporter())20}21import (22func main() {23	fmt.Println(reporter.Reporter())24}25import (26func main() {27	fmt.Println(reporter.Reporter())28}29import (30func main() {31	fmt.Println(reporter.Reporter())32}33import (34func main() {35	fmt.Println(reporter.Reporter())36}37import (38func main() {39	fmt.Println(reporter.Reporter())40}41import (42func main() {43	fmt.Println(reporter.Reporter())44}45import (46func main() {47	fmt.Println(reporter.Reporter())

1import (2func main() {3	fmt.Println("Hello, playground")4	reporter.Report()5}6import (7func main() {8	fmt.Println("Hello, playground")9	reporter.Report()10}11import (12func main() {13	fmt.Println("Hello, playground")14	reporter.Report()15}16import (17func main() {18	fmt.Println("Hello, playground")19	reporter.Report()20}21import (22func main() {23	fmt.Println("Hello, playground")24	reporter.Report()25}26import (27func main() {28	fmt.Println("Hello, playground")29	reporter.Report()30}31import (32func main() {33	fmt.Println("Hello, playground")34	reporter.Report()35}36import (37func main() {38	fmt.Println("Hello, playground")39	reporter.Report()40}41import (42func main() {43	fmt.Println("Hello, playground")44	reporter.Report()45}46import (47func main() {48	fmt.Println("Hello, playground")49	reporter.Report()50}51import (52func main() {53	fmt.Println("Hello, playground")

1import "fmt"2func main(){3    fmt.Println("Enter the number of elements of array")4    fmt.Scan(&a)5    for i:=0;i<a;i++{6        fmt.Scan(&arr[i])7    }8    fmt.Println("Enter the number to be searched")9    fmt.Scan(&b)10    for i:=0;i<a;i++{11        if arr[i]==b{12            fmt.Println("Element found at index",i)13        }14    }15}

1import "fmt"2func main() {3  fmt.Println("Hello World!")4  reporter := reporter()5  reporter.reporter()6}7import "fmt"8func reporter() {9  fmt.Println("Reporter Class")10}11import "fmt"12func reporter() {13  fmt.Println("Reporter Method")14}

1import "fmt"2import "github.com/username/firstrepo/reporter"3func main() {4    fmt.Println("Hello, 世界")5    reporter.Report()6}7import "fmt"8import "github.com/username/firstrepo/reporter"9func main() {10    fmt.Println("Hello, 世界")11    reporter.Report()12}13import "fmt"14import "github.com/username/firstrepo/reporter"15func main() {16    fmt.Println("Hello, 世界")17    reporter.Report()18}19import "fmt"20import "github.com/username/firstrepo/reporter"21func main() {22    fmt.Println("Hello, 世界")23    reporter.Report()24}25import "fmt"26import "github.com/username/firstrepo/reporter"27func main() {28    fmt.Println("Hello, 世界")29    reporter.Report()30}31import "fmt"32import "github.com/username/firstrepo/reporter"33func main() {34    fmt.Println("Hello, 世界")35    reporter.Report()36}37import "fmt"38import "github.com/username/firstrepo/reporter"39func main() {40    fmt.Println("Hello, 世界")41    reporter.Report()42}43import "fmt"44import "github.com/username/firstrepo/reporter"45func main() {46    fmt.Println("Hello, 世界")47    reporter.Report()48}49import "fmt"50import "github.com/username/firstrepo/reporter"51func main() {52    fmt.Println("Hello, 世界")53    reporter.Report()54}

1import (2func main() {3	reporter := goreporter.NewReporter()4	reporter.Report()5}6import (7func main() {8	reporter := goreporter.NewReporter()9	reporter.Report()10}11import (12func main() {13	reporter := goreporter.NewReporter()14	reporter.Report()15}16import (17func main() {18	reporter := goreporter.NewReporter()19	reporter.Report()20}21import (22func main() {23	reporter := goreporter.NewReporter()24	reporter.Report()25}26import (27func main() {28	reporter := goreporter.NewReporter()29	reporter.Report()30}31import (32func main() {33	reporter := goreporter.NewReporter()34	reporter.Report()35}36import (37func main() {38	reporter := goreporter.NewReporter()39	reporter.Report()40}41import (

1import "fmt"2func main() {3r.reporter()4}5import "fmt"6func main() {7r.reporter()8}