Add samples for collectors, sinks and receivers

collectors/sampleTimerMetric.go

@@ -0,0 +1,122 @@
+package collectors
+
+import (
+	"encoding/json"
+	"sync"
+	"time"
+
+	cclog "github.com/ClusterCockpit/cc-metric-collector/internal/ccLogger"
+	lp "github.com/ClusterCockpit/cc-metric-collector/internal/ccMetric"
+)
+
+// These are the fields we read from the JSON configuration
+type SampleTimerCollectorConfig struct {
+	Interval string `json:"interval"`
+}
+
+// This contains all variables we need during execution and the variables
+// defined by metricCollector (name, init, ...)
+type SampleTimerCollector struct {
+	metricCollector
+	wg       sync.WaitGroup             // sync group for management
+	done     chan bool                  // channel for management
+	meta     map[string]string          // default meta information
+	tags     map[string]string          // default tags
+	config   SampleTimerCollectorConfig // the configuration structure
+	interval time.Duration              // the interval parsed from configuration
+	ticker   *time.Ticker               // own timer
+	output   chan lp.CCMetric           // own internal output channel
+}
+
+func (m *SampleTimerCollector) Init(name string, config json.RawMessage) error {
+	var err error = nil
+	// Always set the name early in Init() to use it in cclog.Component* functions
+	m.name = "SampleTimerCollector"
+	// This is for later use, also call it early
+	m.setup()
+	// Define meta information sent with each metric
+	// (Can also be dynamic or this is the basic set with extension through AddMeta())
+	m.meta = map[string]string{"source": m.name, "group": "SAMPLE"}
+	// Define tags sent with each metric
+	// The 'type' tag is always needed, it defines the granulatity of the metric
+	// node -> whole system
+	// socket -> CPU socket (requires socket ID as 'type-id' tag)
+	// cpu -> single CPU hardware thread (requires cpu ID as 'type-id' tag)
+	m.tags = map[string]string{"type": "node"}
+	// Read in the JSON configuration
+	if len(config) > 0 {
+		err = json.Unmarshal(config, &m.config)
+		if err != nil {
+			cclog.ComponentError(m.name, "Error reading config:", err.Error())
+			return err
+		}
+	}
+	// Parse the read interval duration
+	m.interval, err = time.ParseDuration(m.config.Interval)
+	if err != nil {
+		cclog.ComponentError(m.name, "Error parsing interval:", err.Error())
+		return err
+	}
+
+	// Storage for output channel
+	m.output = nil
+	// Mangement channel for the timer function.
+	m.done = make(chan bool)
+	// Create the own ticker
+	m.ticker = time.NewTicker(m.interval)
+
+	// Start the timer loop with return functionality by sending 'true' to the done channel
+	m.wg.Add(1)
+	go func() {
+		select {
+		case <-m.done:
+			// Exit the timer loop
+			cclog.ComponentDebug(m.name, "Closing...")
+			m.wg.Done()
+			return
+		case timestamp := <-m.ticker.C:
+			// This is executed every timer tick but we have to wait until the first
+			// Read() to get the output channel
+			if m.output != nil {
+				m.ReadMetrics(timestamp)
+			}
+		}
+	}()
+
+	// Set this flag only if everything is initialized properly, all required files exist, ...
+	m.init = true
+	return err
+}
+
+// This function is called at each interval timer tick
+func (m *SampleTimerCollector) ReadMetrics(timestamp time.Time) {
+	// Create a sample metric
+
+	value := 1.0
+
+	// If you want to measure something for a specific amout of time, use interval
+	// start := readState()
+	// time.Sleep(interval)
+	// stop := readState()
+	// value = (stop - start) / interval.Seconds()
+
+	y, err := lp.New("sample_metric", m.tags, m.meta, map[string]interface{}{"value": value}, timestamp)
+	if err == nil && m.output != nil {
+		// Send it to output channel if we have a valid channel
+		m.output <- y
+	}
+}
+
+func (m *SampleTimerCollector) Read(interval time.Duration, output chan lp.CCMetric) {
+	// Capture output channel
+	m.output = output
+}
+
+func (m *SampleTimerCollector) Close() {
+	// Send signal to the timer loop to stop it
+	m.done <- true
+	// Wait until the timer loop is done
+	m.wg.Wait()
+	// Unset flag
+	m.init = false
+}