func addStandardAndWorkflowTags(m core.Metric, allTags map[string]map[string]string) core.Metric {
hostname := hostnameReader.Hostname()
tags := m.Tags()
if tags == nil {
tags = map[string]string{}
}
// apply tags from workflow
for ns, nsTags := range allTags {
if strings.HasPrefix(m.Namespace().String(), ns) {
for k, v := range nsTags {
tags[k] = v
}
}
}
// apply standard tag
tags[core.STD_TAG_PLUGIN_RUNNING_ON] = hostname
metric := plugin.MetricType{
Namespace_: m.Namespace(),
Version_: m.Version(),
LastAdvertisedTime_: m.LastAdvertisedTime(),
Config_: m.Config(),
Data_: m.Data(),
Tags_: tags,
Description_: m.Description(),
Unit_: m.Unit(),
Timestamp_: m.Timestamp(),
}
return metric
}
func (mc *metricCatalog) AddLoadedMetricType(lp *loadedPlugin, mt core.Metric) error {
if err := validateMetricNamespace(mt.Namespace()); err != nil {
log.WithFields(log.Fields{
"_module": "control",
"_file": "metrics.go,",
"_block": "add-loaded-metric-type",
"error": fmt.Errorf("Metric namespace %s is invalid", mt.Namespace()),
}).Error("error adding loaded metric type")
return err
}
if lp.ConfigPolicy == nil {
err := errors.New("Config policy is nil")
log.WithFields(log.Fields{
"_module": "control",
"_file": "metrics.go,",
"_block": "add-loaded-metric-type",
"error": err,
}).Error("error adding loaded metric type")
return err
}
newMt := metricType{
Plugin: lp,
namespace: mt.Namespace(),
version: mt.Version(),
lastAdvertisedTime: mt.LastAdvertisedTime(),
tags: mt.Tags(),
policy: lp.ConfigPolicy.Get(mt.Namespace().Strings()),
description: mt.Description(),
unit: mt.Unit(),
}
mc.Add(&newMt)
return nil
}
func (mc *metricCatalog) AddLoadedMetricType(lp *loadedPlugin, mt core.Metric) {
if lp.ConfigPolicy == nil {
panic("NO")
}
newMt := metricType{
Plugin: lp,
namespace: mt.Namespace(),
version: mt.Version(),
lastAdvertisedTime: mt.LastAdvertisedTime(),
tags: mt.Tags(),
labels: mt.Labels(),
policy: lp.ConfigPolicy.Get(mt.Namespace()),
}
mc.Add(&newMt)
}
func ToMetric(co core.Metric) *rpc.Metric {
cm := &rpc.Metric{
Namespace: ToNamespace(co.Namespace()),
Version: int64(co.Version()),
Tags: co.Tags(),
Timestamp: &rpc.Time{
Sec: co.Timestamp().Unix(),
Nsec: int64(co.Timestamp().Nanosecond()),
},
LastAdvertisedTime: &rpc.Time{
Sec: co.LastAdvertisedTime().Unix(),
Nsec: int64(co.Timestamp().Nanosecond()),
},
}
if co.Config() != nil {
cm.Config = ConfigToConfigMap(co.Config())
}
switch t := co.Data().(type) {
case string:
cm.Data = &rpc.Metric_StringData{t}
case float64:
cm.Data = &rpc.Metric_Float64Data{t}
case float32:
cm.Data = &rpc.Metric_Float32Data{t}
case int32:
cm.Data = &rpc.Metric_Int32Data{t}
case int:
cm.Data = &rpc.Metric_Int64Data{int64(t)}
case int64:
cm.Data = &rpc.Metric_Int64Data{t}
case []byte:
cm.Data = &rpc.Metric_BytesData{t}
case bool:
cm.Data = &rpc.Metric_BoolData{t}
case nil:
cm.Data = nil
default:
log.Error(fmt.Sprintf("unsupported type: %s", t))
}
return cm
}
func addStandardAndWorkflowTags(m core.Metric, allTags map[string]map[string]string) core.Metric {
hostname, err := hostnameReader.Hostname()
if err != nil {
log.WithFields(log.Fields{
"_module": "control",
"_file": "metrics.go,",
"_block": "addStandardAndWorkflowTags",
"error": err.Error(),
}).Error("Unable to determine hostname")
}
tags := m.Tags()
if tags == nil {
tags = map[string]string{}
}
// apply tags from workflow
for ns, nsTags := range allTags {
if strings.HasPrefix(m.Namespace().String(), ns) {
for k, v := range nsTags {
tags[k] = v
}
}
}
// apply standard tag
tags[core.STD_TAG_PLUGIN_RUNNING_ON] = hostname
metric := plugin.MetricType{
Namespace_: m.Namespace(),
Version_: m.Version(),
LastAdvertisedTime_: m.LastAdvertisedTime(),
Config_: m.Config(),
Data_: m.Data(),
Tags_: tags,
Description_: m.Description(),
Unit_: m.Unit(),
Timestamp_: m.Timestamp(),
}
return metric
}
// Convert a core.Metric to common.Metric protobuf message
func ToMetric(co core.Metric) *Metric {
cm := &Metric{
Namespace: ToNamespace(co.Namespace()),
Version: int64(co.Version()),
Tags: co.Tags(),
Timestamp: &Time{
Sec: co.Timestamp().Unix(),
Nsec: int64(co.Timestamp().Nanosecond()),
},
LastAdvertisedTime: &Time{
Sec: co.LastAdvertisedTime().Unix(),
Nsec: int64(co.Timestamp().Nanosecond()),
},
}
if co.Config() != nil {
cm.Config = ConfigToConfigMap(co.Config())
}
switch t := co.Data().(type) {
case string:
cm.Data = &Metric_StringData{t}
case float64:
cm.Data = &Metric_Float64Data{t}
case float32:
cm.Data = &Metric_Float32Data{t}
case int32:
cm.Data = &Metric_Int32Data{t}
case int:
cm.Data = &Metric_Int64Data{int64(t)}
case int64:
cm.Data = &Metric_Int64Data{t}
case []byte:
cm.Data = &Metric_BytesData{t}
default:
panic(t)
}
return cm
}