Prometheus

func main() {
	http.Handle(*metricsPath, newHandler(!*disableExporterMetrics, *maxRequests))
	if err := http.ListenAndServe(*listenAddress, nil); err != nil { log.Fatal(err) }

func newHandler(includeExporterMetrics bool, maxRequests int) *handler {
	h := &handler{... }
	if innerHandler, err := h.innerHandler(); err != nil {...}
	return h
}

// innerHandler is used to create buth the one unfiltered http.Handler to be
// wrapped by the outer handler and also the filtered handlers created on the
// fly. The former is accomplished by calling innerHandler without any arguments
// (in which case it will log all the collectors enabled via command-line
// flags).
func (h *handler) innerHandler(filters ...string) (http.Handler, error) {
	nc := collector.NewNodeCollector(filters...)
	r := prometheus.NewRegistry()
	r.MustRegister(version.NewCollector("node_exporter"))
	r.Register(nc)
	handler := promhttp.HandlerFor(
		prometheus.Gatherers{h.exporterMetricsRegistry, r},
		promhttp.HandlerOpts{
			ErrorLog:            log.NewErrorLogger(),
			ErrorHandling:       promhttp.ContinueOnError,
			MaxRequestsInFlight: h.maxRequests,
		},
	)
	return handler, nil
}

// HandlerFor returns an uninstrumented http.Handler for the provided Gatherer. 
func HandlerFor(reg prometheus.Gatherer, opts HandlerOpts) http.Handler {
	h := http.HandlerFunc(func(rsp http.ResponseWriter, req *http.Request) {
		mfs := reg.Gather()
		w := io.Writer(rsp)
		enc := expfmt.NewEncoder(w, contentType)
		for _, mf := range mfs {
			if err := enc.Encode(mf); err != nil {
}

// Gather implements Gatherer.
func (r *Registry) Gather() ([]*dto.MetricFamily, error) {
	r.mtx.RLock()
	checkedCollectors := make(chan Collector, len(r.collectorsByID))
	for _, collector := range r.collectorsByID {
		checkedCollectors <- collector
	}
	r.mtx.RUnlock()

	collectWorker := func() {
            collector := <-checkedCollectors:
            collector.Collect(checkedMetricChan)
	}

	// Start the first worker now to make sure at least one is running.
	go collectWorker()
	return internal.NormalizeMetricFamilies(metricFamiliesByName), errs.MaybeUnwrap()
}

// Collector is the interface implemented by anything that can be used by
// Prometheus to collect metrics. 
type Collector interface {
	// Collect is called by the Prometheus registry when collecting
	// metrics. The implementation sends each collected metric via the
	// provided channel and returns once the last metric has been sent. 
	Collect(chan<- Metric)
}

~/repos/external/prom $ tree node_exporter/collector/ -L 1 | grep cpu_
├── cpu_common.go
├── cpu_darwin.go
├── cpu_dragonfly.go
├── cpu_dragonfly_test.go
├── cpu_freebsd.go
├── cpu_linux.go
├── cpu_openbsd.go
├── cpu_solaris.go

// updateStat reads /proc/stat through procfs and exports cpu related metrics.
func (c *cpuCollector) updateStat(ch chan<- prometheus.Metric) error {
	stats, err := c.fs.Stat()
	if err != nil {
		return err
}

// FS represents the pseudo-filesystem sys, which provides an interface to
// kernel data structures.
type FS struct {
	proc fs.FS
}

The procfs library is organized by packages based on whether the gathered data
is coming from /proc, /sys, or both. Each package contains an FS type which
represents the path to either /proc, /sys, or both. For example, current cpu
statistics are gathered from /proc/stat and are available via the root procfs
package.

// Stat returns information about current cpu/process statistics.
// See https://www.kernel.org/doc/Documentation/filesystems/proc.txt
func (fs FS) Stat() (Stat, error) {

	f, err := os.Open(fs.proc.Path("stat"))
	if err != nil {
		return Stat{}, err
	}
	defer f.Close()

stat := Stat{}

        // ----------------------------------------------
        // [ME] read from file
        // ----------------------------------------------
	scanner := bufio.NewScanner(f)
	for scanner.Scan() {
                // ----------------------------------------------
                // [ME] break file into lines
                // ----------------------------------------------
		line := scanner.Text()
                // ----------------------------------------------
                // [ME] break lines into parts based on white space separation
                // ----------------------------------------------
		parts := strings.Fields(scanner.Text())
		// require at least <key> <value>
		if len(parts) < 2 {
			continue
		}
		switch {
		case parts[0] == "btime":
                        // ----------------------------------------------
                        // [ME] parse string into UINT
                        // ----------------------------------------------
			if stat.BootTime, err = strconv.ParseUint(parts[1], 10, 64); err != nil {
				return Stat{}, fmt.Errorf("couldn't parse %s (btime): %s", parts[1], err)

                ...

	for cpuID, cpuStat := range stats.CPU {
		cpuNum := fmt.Sprintf("%d", cpuID)
                ch <- prometheus.MustNewConstMetric(c.cpu, prometheus.CounterValue, cpuStat.User, cpuNum, "user")
                ...

If you already have metrics available, created outside of the Prometheus
context, you don't need the interface of the various Metric types. You
essentially want to mirror the existing numbers into Prometheus Metrics during
collection. An own implementation of the Collector interface is perfect for
that.

// NewConstMetric returns an error if the length of
// labelValues is not consistent with the variable labels in Desc or if Desc is
// invalid.

node_exporter 
    -> http.Handler 
        -> onRequest 
            -> Gather 
                -> Collect 
                    -> CPU_Collector 
                        -> Procfs 
                            -> read from the linux procfs pseudo file system
                                -> prometheus.MustNewConstMetric(...)