// Do the plugin
func Do() {
optAccessKeyID := flag.String("access-key-id", "", "AWS Access Key ID")
optSecretAccessKey := flag.String("secret-access-key", "", "AWS Secret Access Key")
optIdentifier := flag.String("identifier", "", "Distribution ID")
optTempfile := flag.String("tempfile", "", "Temp file name")
flag.Parse()
var plugin CloudFrontPlugin
plugin.AccessKeyID = *optAccessKeyID
plugin.SecretAccessKey = *optSecretAccessKey
plugin.Name = *optIdentifier
err := plugin.prepare()
if err != nil {
log.Fatalln(err)
}
helper := mp.NewMackerelPlugin(plugin)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
helper.Tempfile = "/tmp/mackerel-plugin-cloudfront"
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
func main() {
flag.StringVar(&Options.Host, "host", "localhost", "fluentd monitor_agent host")
flag.IntVar(&Options.Port, "port", 24220, "fluentd monitor_agent port")
flag.StringVar(&Options.Tempfile, "tempfile", "", "Temp file name")
flag.Parse()
plugin := Plugin{
Target: fmt.Sprintf("http://%s:%d/api/plugins.json", Options.Host, Options.Port),
}
plugin.Prepare()
helper := mp.NewMackerelPlugin(plugin)
if Options.Tempfile != "" {
helper.Tempfile = Options.Tempfile
} else {
helper.Tempfile = fmt.Sprintf("/tmp/mackerel-plugin-fluentd-%s-%d", Options.Host, Options.Port)
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
func main() {
optUri := flag.String("uri", "", "URI")
optScheme := flag.String("scheme", "http", "Scheme")
optHost := flag.String("host", "localhost", "Hostname")
optPort := flag.String("port", "8080", "Port")
optPath := flag.String("path", "/nginx_status", "Path")
optTempfile := flag.String("tempfile", "", "Temp file name")
flag.Parse()
var nginx NginxPlugin
if *optUri != "" {
nginx.Uri = *optUri
} else {
nginx.Uri = fmt.Sprintf("%s://%s:%s%s", *optScheme, *optHost, *optPort, *optPath)
}
helper := mp.NewMackerelPlugin(nginx)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
helper.Tempfile = fmt.Sprintf("/tmp/mackerel-plugin-nginx")
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
func main() {
optAPIKey := flag.String("api-key", "", "API Key")
optDatabase := flag.String("database", "", "Database name")
optIgnoreTableNames := flag.String("ignore-table", "", "Ignore Table name (Can be Comma-Separated)")
optTempfile := flag.String("tempfile", "", "Temp file name")
flag.Parse()
var plugin TDTablePlugin
plugin.APIKey = *optAPIKey
plugin.Database = *optDatabase
ignoreTableNames := []string{}
if *optIgnoreTableNames != "" {
ignoreTableNames = strings.Split(*optIgnoreTableNames, ",")
}
plugin.IgnoreTableNames = ignoreTableNames
helper := mp.NewMackerelPlugin(plugin)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
helper.Tempfile = "/tmp/mackerel-plugin-td-table"
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
func main() {
optHost := flag.String("host", "localhost", "Hostname")
optPort := flag.String("port", "3306", "Port")
optUser := flag.String("username", "root", "Username")
optPass := flag.String("password", "", "Password")
optTempfile := flag.String("tempfile", "", "Temp file name")
flag.Parse()
var mysql MySQLPlugin
mysql.Target = fmt.Sprintf("%s:%s", *optHost, *optPort)
mysql.Username = *optUser
mysql.Password = *optPass
helper := mp.NewMackerelPlugin(mysql)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
helper.Tempfile = fmt.Sprintf("/tmp/mackerel-plugin-mysql-%s-%s", *optHost, *optPort)
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
func main() {
optRegion := flag.String("region", "", "AWS Region")
optInstanceID := flag.String("instance-id", "", "Instance ID")
optAccessKeyID := flag.String("access-key-id", "", "AWS Access Key ID")
optSecretAccessKey := flag.String("secret-access-key", "", "AWS Secret Access Key")
optTempfile := flag.String("tempfile", "", "Temp file name")
flag.Parse()
var cpucredit CPUCreditPlugin
if *optRegion == "" || *optInstanceID == "" {
cpucredit.Region = aws.InstanceRegion()
cpucredit.InstanceID = aws.InstanceId()
} else {
cpucredit.Region = *optRegion
cpucredit.InstanceID = *optInstanceID
}
cpucredit.AccessKeyID = *optAccessKeyID
cpucredit.SecretAccessKey = *optSecretAccessKey
helper := mp.NewMackerelPlugin(cpucredit)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
helper.Tempfile = "/tmp/mackerel-plugin-cpucredit"
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
// Do the plugin
func Do() {
optScheme := flag.String("scheme", "http", "Scheme")
optHost := flag.String("host", "localhost", "Host")
optPort := flag.String("port", "9200", "Port")
optPrefix := flag.String("metric-key-prefix", "elasticsearch", "Metric key prefix")
optLabelPrefix := flag.String("metric-label-prefix", "", "Metric Label prefix")
optTempfile := flag.String("tempfile", "", "Temp file name")
flag.Parse()
var elasticsearch ElasticsearchPlugin
elasticsearch.URI = fmt.Sprintf("%s://%s:%s", *optScheme, *optHost, *optPort)
elasticsearch.Prefix = *optPrefix
if *optLabelPrefix == "" {
elasticsearch.LabelPrefix = strings.Title(*optPrefix)
} else {
elasticsearch.LabelPrefix = *optLabelPrefix
}
helper := mp.NewMackerelPlugin(elasticsearch)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
helper.Tempfile = fmt.Sprintf("/tmp/mackerel-plugin-elasticsearch-%s-%s", *optHost, *optPort)
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
func main() {
optEndpoint := flag.String("endpoint", "", "AWS Endpoint")
optAccessKeyID := flag.String("access-key-id", "", "AWS Access Key ID")
optSecretAccessKey := flag.String("secret-access-key", "", "AWS Secret Access Key")
optTempfile := flag.String("tempfile", "", "Temp file name")
flag.Parse()
var ses SESPlugin
ses.Endpoint = *optEndpoint
ses.AccessKeyID = *optAccessKeyID
ses.SecretAccessKey = *optSecretAccessKey
helper := mp.NewMackerelPlugin(ses)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
helper.Tempfile = "/tmp/mackerel-plugin-ses"
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
func main() {
optHost := flag.String("host", "localhost", "Hostname")
optPort := flag.String("port", "8983", "Port")
optTempfile := flag.String("tempfile", "", "Temp file name")
flag.Parse()
solr := SolrPlugin{
Protocol: "http",
Host: *optHost,
Port: *optPort,
Prefix: "solr",
}
solr.BaseURL = fmt.Sprintf("%s://%s:%s/solr", solr.Protocol, solr.Host, solr.Port)
solr.loadStats()
helper := mp.NewMackerelPlugin(solr)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
helper.Tempfile = fmt.Sprintf("/tmp/mackerel-plugin-%s-%s-%s", solr.Prefix, *optHost, *optPort)
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
func main() {
optRegion := flag.String("region", "", "AWS Region")
optAccessKeyId := flag.String("access-key-id", "", "AWS Access Key ID")
optSecretAccessKey := flag.String("secret-access-key", "", "AWS Secret Access Key")
optIdentifier := flag.String("identifier", "", "DB Instance Identifier")
optTempfile := flag.String("tempfile", "", "Temp file name")
flag.Parse()
var rds RDSPlugin
if *optRegion == "" {
rds.Region = aws.InstanceRegion()
} else {
rds.Region = *optRegion
}
rds.Identifier = *optIdentifier
rds.AccessKeyId = *optAccessKeyId
rds.SecretAccessKey = *optSecretAccessKey
helper := mp.NewMackerelPlugin(rds)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
helper.Tempfile = "/tmp/mackerel-plugin-rds"
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
func main() {
optHost := flag.String("host", "127.0.0.1", "Hostname")
optPort := flag.String("port", "6379", "port")
optTempfile := flag.String("tempfile", "", "Temp file name")
optDB := flag.String("db", "0", "Database")
optNamespace := flag.String("namespace", "", "Namespace")
flag.Parse()
var sidekiq SidekiqPlugin
sidekiq.Target = *optHost + ":" + *optPort
sidekiq.Database = *optDB
sidekiq.Namespace = *optNamespace
helper := mp.NewMackerelPlugin(sidekiq)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
helper.Tempfile = "/tmp/mackerel-plugin-sidekiq-" + *optHost + "-" + *optPort
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
// main function
func doMain(c *cli.Context) {
var linux LinuxPlugin
linux.Type = c.String("type")
helper := mp.NewMackerelPlugin(linux)
helper.Tempfile = c.String("tempfile")
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
func main() {
optHost := flag.String("hostname", "localhost", "Hostname to login to")
optPort := flag.String("port", "5432", "Database port")
optUser := flag.String("user", "", "Postgres User")
optDatabase := flag.String("database", "", "Database name")
optPass := flag.String("password", "", "Postgres Password")
optSSLmode := flag.String("sslmode", "disable", "Whether or not to use SSL")
optConnectTimeout := flag.Int("connect_timeout", 5, "Maximum wait for connection, in seconds.")
optTempfile := flag.String("tempfile", "", "Temp file name")
flag.Parse()
if *optUser == "" {
logger.Warningf("user is required")
flag.PrintDefaults()
os.Exit(1)
}
if *optPass == "" {
logger.Warningf("password is required")
flag.PrintDefaults()
os.Exit(1)
}
option := ""
if *optDatabase != "" {
option = fmt.Sprintf("dbname=%s", *optDatabase)
}
var postgres PostgresPlugin
postgres.Host = *optHost
postgres.Port = *optPort
postgres.Username = *optUser
postgres.Password = *optPass
postgres.SSLmode = *optSSLmode
postgres.Timeout = *optConnectTimeout
postgres.Option = option
helper := mp.NewMackerelPlugin(postgres)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
helper.Tempfile = fmt.Sprintf("/tmp/mackerel-plugin-postgres-%s-%s", *optHost, *optPort)
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
func main() {
optGraphName := flag.String("name", "snmp", "Graph name")
optGraphUnit := flag.String("unit", "float", "Graph unit")
optHost := flag.String("host", "localhost", "Hostname")
optCommunity := flag.String("community", "public", "SNMP V2c Community")
optTempfile := flag.String("tempfile", "", "Temp file name")
flag.Parse()
var snmp SNMPPlugin
snmp.Host = *optHost
snmp.Community = *optCommunity
snmp.GraphName = *optGraphName
snmp.GraphUnit = *optGraphUnit
sms := []SNMPMetrics{}
for _, arg := range flag.Args() {
vals := strings.Split(arg, ":")
if len(vals) < 2 {
continue
}
mpm := mp.Metrics{Name: vals[1], Label: vals[1]}
if len(vals) >= 3 {
mpm.Diff, _ = strconv.ParseBool(vals[2])
}
if len(vals) >= 4 {
mpm.Stacked, _ = strconv.ParseBool(vals[3])
}
sms = append(sms, SNMPMetrics{OID: vals[0], Metrics: mpm})
}
snmp.SNMPMetricsSlice = sms
helper := mp.NewMackerelPlugin(snmp)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
helper.Tempfile = fmt.Sprintf("/tmp/mackerel-plugin-snmp-%s-%s", *optHost, *optGraphName)
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
// Do the plugin
func Do() {
optRegion := flag.String("region", "", "AWS Region")
optAccessKeyID := flag.String("access-key-id", "", "AWS Access Key ID")
optSecretAccessKey := flag.String("secret-access-key", "", "AWS Secret Access Key")
optIdentifier := flag.String("identifier", "", "DB Instance Identifier")
optEngine := flag.String("engine", "", "RDS Engine")
optPrefix := flag.String("metric-key-prefix", "rds", "Metric key prefix")
optLabelPrefix := flag.String("metric-label-prefix", "", "Metric Label prefix")
optTempfile := flag.String("tempfile", "", "Temp file name")
flag.Parse()
rds := RDSPlugin{
Prefix: *optPrefix,
}
if *optLabelPrefix == "" {
if *optPrefix == "rds" {
rds.LabelPrefix = "RDS"
} else {
rds.LabelPrefix = strings.Title(*optPrefix)
}
} else {
rds.LabelPrefix = *optLabelPrefix
}
if *optRegion == "" {
rds.Region = aws.InstanceRegion()
} else {
rds.Region = *optRegion
}
rds.Identifier = *optIdentifier
rds.AccessKeyID = *optAccessKeyID
rds.SecretAccessKey = *optSecretAccessKey
rds.Engine = *optEngine
helper := mp.NewMackerelPlugin(rds)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
helper.Tempfile = "/tmp/mackerel-plugin-rds"
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
func doMain(c *cli.Context) {
var phpopcache PhpOpcachePlugin
phpopcache.Host = c.String("http_host")
phpopcache.Port = uint16(c.Int("http_port"))
phpopcache.Path = c.String("status_page")
helper := mp.NewMackerelPlugin(phpopcache)
helper.Tempfile = c.String("tempfile")
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
func main() {
optRegion := flag.String("region", "", "AWS Region")
optAccessKeyID := flag.String("access-key-id", "", "AWS Access Key ID")
optSecretAccessKey := flag.String("secret-access-key", "", "AWS Secret Access Key")
optCacheClusterID := flag.String("cache-cluster-id", "", "Cache Cluster Id")
optCacheNodeID := flag.String("cache-node-id", "0001", "Cache Node Id")
optElastiCacheType := flag.String("elasticache-type", "", "ElastiCache type")
optTempfile := flag.String("tempfile", "", "Temp file name")
flag.Parse()
var ecache ECachePlugin
if *optRegion == "" {
ecache.Region = aws.InstanceRegion()
} else {
ecache.Region = *optRegion
}
ecache.AccessKeyID = *optAccessKeyID
ecache.SecretAccessKey = *optSecretAccessKey
ecache.CacheClusterID = *optCacheClusterID
ecache.CacheNodeID = *optCacheNodeID
ecache.ElastiCacheType = *optElastiCacheType
switch ecache.ElastiCacheType {
case "memcached":
ecache.CacheMetrics = metricsdefMemcached
case "redis":
ecache.CacheMetrics = metricsdefRedis
default:
log.Printf("elasticache-type is 'memcached' or 'redis'.")
os.Exit(1)
}
helper := mp.NewMackerelPlugin(ecache)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
helper.Tempfile = fmt.Sprintf("/tmp/mackerel-plugin-aws-elasticache-%s-%s", *optCacheClusterID, *optCacheNodeID)
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
// main function
func doMain(c *cli.Context) {
var apache2 Apache2Plugin
apache2.Host = c.String("http_host")
apache2.Port = uint16(c.Int("http_port"))
apache2.Path = c.String("status_page")
apache2.Header = c.StringSlice("header")
helper := mp.NewMackerelPlugin(apache2)
helper.Tempfile = c.String("tempfile")
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
func main() {
optRegion := flag.String("region", "", "AWS Region")
optInstanceID := flag.String("instance-id", "", "Instance ID")
optAccessKeyID := flag.String("access-key-id", "", "AWS Access Key ID")
optSecretAccessKey := flag.String("secret-access-key", "", "AWS Secret Access Key")
optTempfile := flag.String("tempfile", "", "Temp file name")
flag.Parse()
var ebs EBSPlugin
ebs.Region = *optRegion
ebs.InstanceID = *optInstanceID
// get metadata in ec2 instance
ec2MC := ec2metadata.New(&ec2metadata.Config{})
if *optRegion == "" {
ebs.Region, _ = ec2MC.Region()
}
if *optInstanceID == "" {
ebs.InstanceID, _ = ec2MC.GetMetadata("instance-id")
}
ebs.AccessKeyID = *optAccessKeyID
ebs.SecretAccessKey = *optSecretAccessKey
if err := ebs.prepare(); err != nil {
log.Fatalln(err)
}
helper := mp.NewMackerelPlugin(ebs)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
helper.Tempfile = "/tmp/mackerel-plugin-ebs"
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
func main() {
optRegion := flag.String("region", "", "AWS Region")
optAccessKeyID := flag.String("access-key-id", "", "AWS Access Key ID")
optSecretAccessKey := flag.String("secret-access-key", "", "AWS Secret Access Key")
optClientID := flag.String("client-id", "", "AWS Client ID")
optDomain := flag.String("domain", "", "ES domain name")
optTempfile := flag.String("tempfile", "", "Temp file name")
flag.Parse()
var es ESPlugin
if *optRegion == "" {
es.Region = aws.InstanceRegion()
} else {
es.Region = *optRegion
}
es.Domain = *optDomain
es.ClientID = *optClientID
es.AccessKeyID = *optAccessKeyID
es.SecretAccessKey = *optSecretAccessKey
err := es.prepare()
if err != nil {
log.Fatalln(err)
}
helper := mp.NewMackerelPlugin(es)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
helper.Tempfile = "/tmp/mackerel-plugin-aws-elasticsearch"
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
// Do the plugin
func Do() {
optAccessKeyID := flag.String("access-key-id", "", "AWS Access Key ID")
optSecretAccessKey := flag.String("secret-access-key", "", "AWS Secret Access Key")
optRegion := flag.String("region", "", "AWS Region")
optInstanceID := flag.String("instance-id", "", "Instance ID")
optTempfile := flag.String("tempfile", "", "Temp file name")
flag.Parse()
var ec2 EC2Plugin
// use credentials from option
if *optAccessKeyID != "" && *optSecretAccessKey != "" {
ec2.Credentials = credentials.NewStaticCredentials(*optAccessKeyID, *optSecretAccessKey, "")
}
// get metadata in ec2 instance
ec2MC := ec2metadata.New(session.New())
ec2.Region = *optRegion
if *optRegion == "" {
ec2.Region, _ = ec2MC.Region()
}
ec2.InstanceID = *optInstanceID
if *optInstanceID == "" {
ec2.InstanceID, _ = ec2MC.GetMetadata("instance-id")
}
helper := mp.NewMackerelPlugin(ec2)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
helper.Tempfile = fmt.Sprintf("/tmp/mackerel-plugin-aws-ec2-%s", ec2.InstanceID)
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
func main() {
optHost := flag.String("host", "localhost", "Hostname")
optPort := flag.String("port", "6379", "Port")
optPassowrd := flag.String("password", "", "Password")
optSocket := flag.String("socket", "", "Server socket (overrides host and port)")
optPrefix := flag.String("metric-key-prefix", "redis", "Metric key prefix")
optTimeout := flag.Int("timeout", 5, "Timeout")
optTempfile := flag.String("tempfile", "", "Temp file name")
flag.Parse()
redis := RedisPlugin{
Timeout: *optTimeout,
Prefix: *optPrefix,
}
if *optSocket != "" {
redis.Socket = *optSocket
} else {
redis.Host = *optHost
redis.Port = *optPort
redis.Password = *optPassowrd
}
helper := mp.NewMackerelPlugin(redis)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
if redis.Socket != "" {
helper.Tempfile = fmt.Sprintf("/tmp/mackerel-plugin-redis-%s", fmt.Sprintf("%x", md5.Sum([]byte(redis.Socket))))
} else {
helper.Tempfile = fmt.Sprintf("/tmp/mackerel-plugin-redis-%s-%s", redis.Host, redis.Port)
}
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
func main() {
optHost := flag.String("host", "localhost", "Hostname")
optPort := flag.String("port", "1099", "Port")
optJstatPath := flag.String("jstatpath", "/usr/bin/jstat", "jstat path")
optJpsPath := flag.String("jpspath", "/usr/bin/jps", "jps path")
optJavaName := flag.String("javaname", "", "Java app name")
optTempfile := flag.String("tempfile", "", "Temp file name")
flag.Parse()
if *optJavaName == "" {
logger.Errorf("javaname is required")
flag.PrintDefaults()
os.Exit(1)
}
var jvm JVMPlugin
jvm.Target = fmt.Sprintf("%s:%s", *optHost, *optPort)
lvmid, err := FetchLvmidByAppname(*optJavaName, jvm.Target, *optJpsPath)
if err != nil {
logger.Errorf("Failed to fetch lvmid. %s", err)
os.Exit(1)
}
jvm.Lvmid = lvmid
jvm.JstatPath = *optJstatPath
jvm.JavaName = *optJavaName
helper := mp.NewMackerelPlugin(jvm)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
helper.Tempfile = fmt.Sprintf("/tmp/mackerel-plugin-jvm-%s", *optHost)
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
// Do the plugin
func Do() {
optURI := flag.String("uri", "", "URI")
optScheme := flag.String("scheme", "http", "Scheme")
optHost := flag.String("host", "localhost", "Hostname")
optPort := flag.String("port", "80", "Port")
optPath := flag.String("path", "/", "Path")
optUsername := flag.String("username", "", "Username for Basic Auth")
optPassword := flag.String("password", "", "Password for Basic Auth")
optTempfile := flag.String("tempfile", "", "Temp file name")
flag.Parse()
var haproxy HAProxyPlugin
if *optURI != "" {
haproxy.URI = *optURI
} else {
haproxy.URI = fmt.Sprintf("%s://%s:%s%s", *optScheme, *optHost, *optPort, *optPath)
}
if *optUsername != "" {
haproxy.Username = *optUsername
}
if *optPassword != "" {
haproxy.Password = *optPassword
}
helper := mp.NewMackerelPlugin(haproxy)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
helper.Tempfile = fmt.Sprintf("/tmp/mackerel-plugin-haproxy")
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
func main() {
optHost := flag.String("host", "localhost", "Host")
optPort := flag.String("port", "9200", "Port")
optTempfile := flag.String("tempfile", "", "Temp file name")
flag.Parse()
var elasticsearch ElasticsearchPlugin
elasticsearch.URI = fmt.Sprintf("http://%s:%s", *optHost, *optPort)
helper := mp.NewMackerelPlugin(elasticsearch)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
helper.Tempfile = fmt.Sprintf("/tmp/mackerel-plugin-elasticsearch-%s-%s", *optHost, *optPort)
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
func main() {
optHost := flag.String("host", "localhost", "Hostname")
optPort := flag.String("port", "11211", "Port")
optTempfile := flag.String("tempfile", "", "Temp file name")
flag.Parse()
var memcached MemcachedPlugin
helper := mp.NewMackerelPlugin(memcached)
memcached.Target = fmt.Sprintf("%s:%s", *optHost, *optPort)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
helper.Tempfile = fmt.Sprintf("/tmp/mackerel-plugin-memcached-%s-%s", *optHost, *optPort)
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
// Do the plugin
func Do() {
optRegion := flag.String("region", "", "AWS Region")
optLbname := flag.String("lbname", "", "ELB Name")
optAccessKeyID := flag.String("access-key-id", "", "AWS Access Key ID")
optSecretAccessKey := flag.String("secret-access-key", "", "AWS Secret Access Key")
optTempfile := flag.String("tempfile", "", "Temp file name")
flag.Parse()
var elb ELBPlugin
if *optRegion == "" {
elb.Region = aws.InstanceRegion()
} else {
elb.Region = *optRegion
}
elb.AccessKeyID = *optAccessKeyID
elb.SecretAccessKey = *optSecretAccessKey
elb.Lbname = *optLbname
err := elb.prepare()
if err != nil {
log.Fatalln(err)
}
helper := mp.NewMackerelPlugin(elb)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
helper.Tempfile = "/tmp/mackerel-plugin-elb"
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
func main() {
optVarnishStatPath := flag.String("varnishstat", "/usr/bin/varnishstat", "Path of varnishstat")
optVarnishName := flag.String("varnish-name", "", "Varnish name")
optTempfile := flag.String("tempfile", "", "Temp file name")
flag.Parse()
var varnish VarnishPlugin
varnish.VarnishStatPath = *optVarnishStatPath
varnish.VarnishName = *optVarnishName
helper := mp.NewMackerelPlugin(varnish)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
helper.Tempfile = "/tmp/mackerel-plugin-varnish"
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
func main() {
optTempfile := flag.String("tempfile", "", "Temp file name")
optXenVersion := flag.Int("xenversion", 4, "Xen Version")
flag.Parse()
var xentop XentopPlugin
xentop.XenVersion = *optXenVersion
helper := mp.NewMackerelPlugin(xentop)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
helper.Tempfile = fmt.Sprintf("/tmp/mackerel-plugin-xentop")
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}
func main() {
optPluginPath := flag.String("plugin", "", "Munin plugin path")
optPluginConfDir := flag.String("plugin-conf-d", "", "Munin plugin-conf.d path")
optGraphName := flag.String("name", "", "Graph name")
optTempfile := flag.String("tempfile", "", "Temp file name")
flag.Parse()
var munin MuninPlugin
if *optPluginPath == "" {
log.Fatalln("Munin plugin path is required")
}
munin.PluginPath = *optPluginPath
munin.PluginConfDir = *optPluginConfDir
if *optGraphName == "" {
munin.GraphName = "munin." + path.Base(munin.PluginPath)
} else {
munin.GraphName = *optGraphName
}
err := munin.Prepare()
if err != nil {
log.Fatalln(err)
}
helper := mp.NewMackerelPlugin(munin)
if *optTempfile != "" {
helper.Tempfile = *optTempfile
} else {
helper.Tempfile = fmt.Sprintf("/tmp/mackerel-plugin-munin-%s", munin.GraphName)
}
if os.Getenv("MACKEREL_AGENT_PLUGIN_META") != "" {
helper.OutputDefinitions()
} else {
helper.OutputValues()
}
}