librato/snap-plugin-utilities

Name: snap-plugin-utilities

Owner: Librato

Description: null

Forked from: intelsdi-x/snap-plugin-utilities

Created: 2018-01-12 07:35:36.0

Updated: 2018-01-12 08:11:21.0

Pushed: 2018-02-06 08:48:12.0

Homepage: null

Size: 106

Language: Go

GitHub Committers

UserMost Recent Commit# Commits

Other Committers

UserEmailMost Recent Commit# Commits

README

snap Plugin Utilities

Build Status GoDoc

Set of packages that provide tools for plugin development

It's used in the snap framework.

  1. Documentation
  2. Features
  3. Examples
  4. Community Support
  5. Contributing
  6. License
  7. Acknowledgements
Documentation
Features:
Examples
[config] package

The config package provides helpful methods to retrive global config items.

See it in action:

if interestingValue, err := GetGlobalConfigItem(cfg, "something_interesting"); err != nil {
    DoSomething(interestingValue)
}


o
interestingItems := []string{"dummy_string", "dummy_bool", "dummy_int", "dummy_float"}

if interestingValues, err := GetGlobalConfigItems(cfg, interestingItems); err != nil {
    for _, interestingValue := range interestingValues {
        DoSomething(interestingValue)
    }
}
[logger] package

The logger package wraps logrus package (https://github.com/Sirupsen/logrus). It sets logging from plugin to separate file. It adds caller function name to each message.

rt (
. "github.com/intelsdi-x/snap-plugin-utilities/logger"


 main() {

LogDebug("Some useful information", "varibale", value)
LogInfo("Some information worth noting", interesting, thing, done)
LogWarn("Take a look on that", warning)
LogError("This is bad", "error", err)
// Exit after
LogFatal("This is really bad", "error", err, value)
// Call panic()
LogPanic("Show me the stacks!")

[ns] package

The ns package provides functions:

It is useful for situations when full knowledge of available metrics is not known at time when GetMetricTypes() is called.

NamespaceFromMap example usage:

Baz := map[string]interface{}{"Bazo": "bazo", "Fazo": "fazo", "Mazo": "mazo"}
Foo := map[string]interface{}{"Foos": "foos", "Boos": "boos"}
Bar := []map[string]interface{}{Baz, Baz}

m := map[string]interface{}{
    "Foo": Foo,
    "Bar": Bar,
}

ns := []string{}
NamespaceFromMap(m, "root", &ns)

/*
ns contains:
"root/Foo/Foos"
"root/Foo/Boos"
"root/Bar/0/Bazo"
"root/Bar/0/Fazo"
"root/Bar/0/Mazo"
"root/Bar/1/Bazo"
"root/Bar/1/Fazo"
"root/Bar/1/Mazo"
*/

NamespaceFromJSON example usage:

Foo := struct {
    Bar struct {
        Qaz []int `json:"qaz"`
        Faz int   `json:"faz"`
    } `json:"bar"`
    Baz string `json:"baz"`
}{
    struct {
        Qaz []int `json:"qaz"`
        Faz int   `json:"faz"`
    }{
        []int{1, 2},
        2,
        },
    "baz_val",
}

data, _ := json.Marshal(Foo)
ns := []string{}

NamespaceFromJSON(&data, "root", &ns)

/*
ns contains:
"root/bar/qaz/0"
"root/bar/qaz/1"
"root/bar/faz"
"root/baz"
*/

NamespaceFromComposition example usage:

Foo := struct {
    Bar struct {
        Qaz []int
        Faz int
    }
    Baz string
}{
    struct {
        Qaz []int
        Faz int
    }{
        []int{1, 2},
        2,
    },
    "baz_val",
}

ns := []string{}
NamespaceFromComposition(Foo, "root", &ns)

/*
ns contains:
"root/Bar/Qaz/0"
"root/Bar/Qaz/1"
"root/Bar/Faz"
"root/Baz"
*/

NamespaceFromCompositionTags example usage:

Foo := struct {
    Bar struct {
        Qaz []int `json:"qaz"`
        Faz int   `json:"faz"`
    } `json:"bar"`
    Baz string `json:"baz"`
}{
    struct {
        Qaz []int `json:"qaz"`
        Faz int   `json:"faz"`
    }{
        []int{1, 2},
        2,
    },
    "baz_val",
}

ns := []string{}
NamespaceFromCompositionTags(Foo, "root", &ns)

/*
ns contains:
"root/bar/qaz/0"
"root/bar/qaz/1"
"root/bar/faz"
"root/baz"
*/

ReplaceNotAllowedCharsInNamespacePart example usage:

 ns := []string{"intel", "plugin", "metric^1"}
for i := range ns {
    ns[i] = ReplaceNotAllowedCharsInNamespacePart(ns[i])
}
/*
ns contains:
"intel"
"plugin"
"metric_1"
*/

ValidateMetricNamespacePart example usage:

ns := []string{"intel", "plugin", "metric^1"}
for i := range ns {
    err := ValidateMetricNamespacePart(ns[i])
    if err != nil {
        fmt.Println(err)
    }
}

FromCompositeObject is a configurable function for building namespaces from all kinds of nested maps, structs and slices. Offers control over inspecting nil pointers, empty containers and exposing struct fields under json tags. Available options include (presented with default values):

ectEmptyContainers(AlwaysTrue),
ectNilPointers(AlwaysTrue),
yForContainersRoot(AlwaysFalse),
rtJsonFieldNames(AlwaysTrue),
cardEntryInContainer(AlwaysFalse),
tizeNamespaceParts(AlwaysTrue).

Example usage:

type first struct {
    Uno bool `json:"uno_f"`
}
type fourth struct {
    Cuatro bool
}
m := struct {
    First  *first         `json:"first_f"`
    Second map[string]int `json:"second_f"`
    Third  int            `json:"-"`
    Fourth []*fourth
}{
    First:  nil,
    Fourth: []*fourth{&fourth{}, &fourth{}}}

ns := []string{}
FromCompositeObject(m, "root", &ns, WildcardEntryInContainer(AlwaysTrue))

// ns contains:
//  "root/first_f/uno_f",
//  "root/second_f/*",
//  "root/Fourth/*/Cuatro",
//  "root/Fourth/0/Cuatro",
//  "root/Fourth/1/Cuatro"
[pipeline] package

Creates array of Processors connected by channels. Each Processor can do single processing on data transmitted by channels

Processor is interface which consists of single method Run, whose arguments are input and output Pipes. Pipe is channel which can through interface{} It can be used to implement transformations on incoming data

type DoNothing struct{}

func (self DoNothing) Run(input, output Pipe) {
        for v := range input {
            output <- v
    }
    close(output)
}   

type StringContains struct{
     Str string
}

func (self StringContains) Run(input, output Pipe) {
        for v := range input {
            if strings.Contains(v.(string), self.Str) {
                output <- v
        }
    }
    close(output)
}

inputPipe := make(Pipe)
outputPipe := Pipeline(inputPipe, DoNothing{}, StringContains{})
[source] package

The source package provides handy way of dealing with external command output. It can be used for continous command execution (EMON or PCM like), or for single command calls.

ech := make(chan error)
out := make(chan interface{})
s := Source{"du", []string{"/some/path", "-h", "--max-depth=10"}}
go s.Generate(out, ech)

LOOP:
for {
    select {
    case data := <-out:
        fmt.Printf(">>> Recieving {%v}\n", data)
    case e := <-ech:
        fmt.Printf("ERRROR {%v}\n", e)
        break LOOP  
    case <-time.After(time.Second * 2):
        fmt.Printf("No activity\n")
        break LOOP 
    }
}
[stack] package

The stack package provides simple implementation of stack.

stack := new(Stack)

for i := 0; i < 5; i++ {
    stack.Push(i)
}

for !stack.Empty() {
    fmt.Printf("%v\n", stack.Pop())
}

/*
prints:
5
4
3
2
1
*/
[str] package

The str package provides helpful methods to work with string sets, maps and slices

See it in action:

Set:

set := InitSet()
set.Add("element")
elements := set.Elements()
set.Delete("element")

Map:

sMap := StringMap{}
sMap["key"] = "val"
keys := sMap.Keys()
values := sMap.Values()
sMap.AddMap(map[string]string{"new": "new"})

Slices

elements := []string{"a_", "b_", "___c", "1", "ab1"}
ForEach(elements, func(e string) string {
    return strings.Replace(e, "_", "", -1)
})

found := Contains(elements, "a")

filtered := Filter(elements, func(e string) bool {
    return strings.Contains(e, "1")
})

found := Any(elements, func(e string) bool {
    return strings.Contains(e, "1")
})

found := All(elements, func(e string) bool {
    return strings.Contains(e, "1")
})
Community Support

This repository is one of many plugins in snap, a powerful telemetry framework. See the full project at http://github.com/intelsdi-x/snap To reach out to other users, head to the main framework

Contributing

We love contributions!

There's more than one way to give back, from examples to blogs to code updates. See our recommended process in CONTRIBUTING.md.

License

snap, along with this plugin, is an Open Source software released under the Apache 2.0 License.

Acknowledgements

Thank you! Your contribution is incredibly important to us.


This work is supported by the National Institutes of Health's National Center for Advancing Translational Sciences, Grant Number U24TR002306. This work is solely the responsibility of the creators and does not necessarily represent the official views of the National Institutes of Health.