hunk.code_window:     constructor() {
           super();
           this.selectedPostId = null;
           this.postsInfo = {};
           this.latestPageTime = {};
           this.currentFocusedPostId = null;
       }
       emitChange() {
           this.emit(CHANGE_EVENT);
  
hunk.labels: keep keep keep keep add keep keep keep keep
hunk.after_edit:         this.earliestPostFromPage = {};
  
hunk.file_path: webapp/stores/post_store.jsx
hunk.type: add
file: // Copyright 2014 The Prometheus Authors
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  //
  // http://www.apache.org/licenses/LICENSE-2.0
  //
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  
  package prometheus_test
  
  import "github.com/prometheus/client_golang/prometheus"
  
  // ClusterManager is an example for a system that might have been built without
  // Prometheus in mind. It models a central manager of jobs running in a
  // cluster. To turn it into something that collects Prometheus metrics, we
  // simply add the two methods required for the Collector interface.
  //
  // An additional challenge is that multiple instances of the ClusterManager are
  // run within the same binary, each in charge of a different zone. We need to
  // make use of ConstLabels to be able to register each ClusterManager instance
  // with Prometheus.
  type ClusterManager struct {
  	Zone         string
  	OOMCountDesc *prometheus.Desc
  	RAMUsageDesc *prometheus.Desc
  	// ... many more fields
  }
  
  // ReallyExpensiveAssessmentOfTheSystemState is a mock for the data gathering a
  // real cluster manager would have to do. Since it may actually be really
  // expensive, it must only be called once per collection. This implementation,
  // obviously, only returns some made-up data.
  func (c *ClusterManager) ReallyExpensiveAssessmentOfTheSystemState() (
  	oomCountByHost map[string]int, ramUsageByHost map[string]float64,
  ) {
  	// Just example fake data.
  	oomCountByHost = map[string]int{
  		"foo.example.org": 42,
  		"bar.example.org": 2001,
  	}
  	ramUsageByHost = map[string]float64{
  		"foo.example.org": 6.023e23,
  		"bar.example.org": 3.14,
  	}
  	return
  }
  
  // Describe simply sends the two Descs in the struct to the channel.
  func (c *ClusterManager) Describe(ch chan<- *prometheus.Desc) {
  	ch <- c.OOMCountDesc
  	ch <- c.RAMUsageDesc
  }
  
  // Collect first triggers the ReallyExpensiveAssessmentOfTheSystemState. Then it
  // creates constant metrics for each host on the fly based on the returned data.
  //
  // Note that Collect could be called concurrently, so we depend on
  // ReallyExpensiveAssessmentOfTheSystemState to be concurrency-safe.
  func (c *ClusterManager) Collect(ch chan<- prometheus.Metric) {
  	oomCountByHost, ramUsageByHost := c.ReallyExpensiveAssessmentOfTheSystemState()
  	for host, oomCount := range oomCountByHost {
  		ch <- prometheus.MustNewConstMetric(
  			c.OOMCountDesc,
  			prometheus.CounterValue,
  			float64(oomCount),
  			host,
  		)
  	}
  	for host, ramUsage := range ramUsageByHost {
  		ch <- prometheus.MustNewConstMetric(
  			c.RAMUsageDesc,
  			prometheus.GaugeValue,
  			ramUsage,
  			host,
  		)
  	}
  }
  
  // NewClusterManager creates the two Descs OOMCountDesc and RAMUsageDesc. Note
  // that the zone is set as a ConstLabel. (It's different in each instance of the
  // ClusterManager, but constant over the lifetime of an instance.) Then there is
  // a variable label "host", since we want to partition the collected metrics by
  // host. Since all Descs created in this way are consistent across instances,
  // with a guaranteed distinction by the "zone" label, we can register different
  // ClusterManager instances with the same registry.
  func NewClusterManager(zone string) *ClusterManager {
  	return &ClusterManager{
  		Zone: zone,
  		OOMCountDesc: prometheus.NewDesc(
  			"clustermanager_oom_crashes_total",
  			"Number of OOM crashes.",
  			[]string{"host"},
  			prometheus.Labels{"zone": zone},
  		),
  		RAMUsageDesc: prometheus.NewDesc(
  			"clustermanager_ram_usage_bytes",
  			"RAM usage as reported to the cluster manager.",
  			[]string{"host"},
  			prometheus.Labels{"zone": zone},
  		),
  	}
  }
  
  func ExampleCollector() {
  	workerDB := NewClusterManager("db")
  	workerCA := NewClusterManager("ca")
  
  	// Since we are dealing with custom Collector implementations, it might
  	// be a good idea to try it out with a pedantic registry.
  	reg := prometheus.NewPedanticRegistry()
  	reg.MustRegister(workerDB)
  	reg.MustRegister(workerCA)
  }
  