provider/datadog: Various enhancements

- Don't drop wildcard if it's the only one.
- Remove monitor resource, it's been replaced by metric_alert,
  outlier_alert and service_check
- Refactor to be closer to the API; each resource creates exactly *one*
  resource, not 2, this removes much unneeded complexity. A warning
  threshold is now supported by the API.
- Remove fuzzy resources like graph, and resources that used them for
  dashboard and screenboards. I'd welcome these resources, but the
  current state of Terraform and the Datadog API does not allow these to
  be implemented in a clean way.
- Support multiple thresholds for metric alerts, remove notify argument.

Author: ojongerius

builtin/providers/datadog/config.go

@@ -0,0 +1,23 @@
+package datadog
+
+import (
+	"log"
+
+	"github.com/zorkian/go-datadog-api"
+)
+
+// Config holds API and APP keys to authenticate to Datadog.
+type Config struct {
+	APIKey string
+	APPKey string
+}
+
+// Client returns a new Datadog client.
+func (c *Config) Client() (*datadog.Client, error) {
+
+	client := datadog.NewClient(c.APIKey, c.APPKey)
+
+	log.Printf("[INFO] Datadog Client configured ")
+
+	return client, nil
+}

builtin/providers/datadog/provider.go

@@ -1,10 +1,13 @@
 package datadog
 
 import (
+	"log"
+
 	"github.com/hashicorp/terraform/helper/schema"
 	"github.com/hashicorp/terraform/terraform"
 )
 
+// Provider returns a terraform.ResourceProvider.
 func Provider() terraform.ResourceProvider {
 	return &schema.Provider{
 		Schema: map[string]*schema.Schema{
@@ -19,15 +22,25 @@ func Provider() terraform.ResourceProvider {
 				DefaultFunc: schema.EnvDefaultFunc("DATADOG_APP_KEY", nil),
 			},
 		},
+
 		ResourcesMap: map[string]*schema.Resource{
-			"datadog_monitor_metric": datadogMonitorResource(),
+			"datadog_service_check": resourceDatadogServiceCheck(),
+			"datadog_metric_alert":  resourceDatadogMetricAlert(),
+			"datadog_outlier_alert": resourceDatadogOutlierAlert(),
 		},
+
 		ConfigureFunc: providerConfigure,
 	}
 }
 
-func providerConfigure(rd *schema.ResourceData) (interface{}, error) {
-	apiKey := rd.Get("api_key").(string)
-	appKey := rd.Get("app_key").(string)
-	return map[string]string{"api_key": apiKey, "app_key": appKey}, nil
+// ProviderConfigure returns a configured client.
+func providerConfigure(d *schema.ResourceData) (interface{}, error) {
+
+	config := Config{
+		APIKey: d.Get("api_key").(string),
+		APPKey: d.Get("app_key").(string),
+	}
+
+	log.Println("[INFO] Initializing Datadog client")
+	return config.Client()
 }

builtin/providers/datadog/provider_test.go

@@ -0,0 +1,38 @@
+package datadog
+
+import (
+	"os"
+	"testing"
+
+	"github.com/hashicorp/terraform/helper/schema"
+	"github.com/hashicorp/terraform/terraform"
+)
+
+var testAccProviders map[string]terraform.ResourceProvider
+var testAccProvider *schema.Provider
+
+func init() {
+	testAccProvider = Provider().(*schema.Provider)
+	testAccProviders = map[string]terraform.ResourceProvider{
+		"datadog": testAccProvider,
+	}
+}
+
+func TestProvider(t *testing.T) {
+	if err := Provider().(*schema.Provider).InternalValidate(); err != nil {
+		t.Fatalf("err: %s", err)
+	}
+}
+
+func TestProvider_impl(t *testing.T) {
+	var _ terraform.ResourceProvider = Provider()
+}
+
+func testAccPreCheck(t *testing.T) {
+	if v := os.Getenv("DATADOG_API_KEY"); v == "" {
+		t.Fatal("DATADOG_API_KEY must be set for acceptance tests")
+	}
+	if v := os.Getenv("DATADOG_APP_KEY"); v == "" {
+		t.Fatal("DATADOG_APP_KEY must be set for acceptance tests")
+	}
+}

builtin/providers/datadog/resource_datadog_metric_alert.go

@@ -0,0 +1,180 @@
+package datadog
+
+import (
+	"bytes"
+	"fmt"
+	"log"
+
+	"github.com/hashicorp/terraform/helper/schema"
+	"github.com/zorkian/go-datadog-api"
+)
+
+// resourceDatadogMetricAlert is a Datadog monitor resource
+func resourceDatadogMetricAlert() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceDatadogMetricAlertCreate,
+		Read:   resourceDatadogGenericRead,
+		Update: resourceDatadogMetricAlertUpdate,
+		Delete: resourceDatadogGenericDelete,
+		Exists: resourceDatadogGenericExists,
+
+		Schema: map[string]*schema.Schema{
+			"name": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+			},
+			"metric": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+			},
+			"tags": &schema.Schema{
+				Type:     schema.TypeList,
+				Optional: true,
+				Elem:     &schema.Schema{Type: schema.TypeString},
+			},
+			"keys": &schema.Schema{
+				Type:     schema.TypeList,
+				Optional: true,
+				Elem:     &schema.Schema{Type: schema.TypeString},
+			},
+			"time_aggr": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+			},
+			"time_window": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+			},
+			"space_aggr": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+			},
+			"operator": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+			},
+			"message": &schema.Schema{
+				Type:     schema.TypeString,
+				Required: true,
+			},
+
+			"thresholds": thresholdSchema(),
+
+			// Additional Settings
+			"notify_no_data": &schema.Schema{
+				Type:     schema.TypeBool,
+				Optional: true,
+				Default:  true,
+			},
+
+			"no_data_timeframe": &schema.Schema{
+				Type:     schema.TypeInt,
+				Optional: true,
+			},
+
+			"renotify_interval": &schema.Schema{
+				Type:     schema.TypeInt,
+				Optional: true,
+				Default:  0,
+			},
+		},
+	}
+}
+
+// buildMonitorStruct returns a monitor struct
+func buildMetricAlertStruct(d *schema.ResourceData) *datadog.Monitor {
+	name := d.Get("name").(string)
+	message := d.Get("message").(string)
+	timeAggr := d.Get("time_aggr").(string)
+	timeWindow := d.Get("time_window").(string)
+	spaceAggr := d.Get("space_aggr").(string)
+	metric := d.Get("metric").(string)
+
+	// Tags are are no separate resource/gettable, so some trickery is needed
+	var buffer bytes.Buffer
+	if raw, ok := d.GetOk("tags"); ok {
+		list := raw.([]interface{})
+		length := (len(list) - 1)
+		for i, v := range list {
+			buffer.WriteString(fmt.Sprintf("%s", v))
+			if i != length {
+				buffer.WriteString(",")
+			}
+
+		}
+	}
+
+	tagsParsed := buffer.String()
+
+	// Keys are used for multi alerts
+	var b bytes.Buffer
+	if raw, ok := d.GetOk("keys"); ok {
+		list := raw.([]interface{})
+		b.WriteString("by {")
+		length := (len(list) - 1)
+		for i, v := range list {
+			b.WriteString(fmt.Sprintf("%s", v))
+			if i != length {
+				b.WriteString(",")
+			}
+
+		}
+		b.WriteString("}")
+	}
+
+	keys := b.String()
+
+	threshold, thresholds := getThresholds(d)
+
+	operator := d.Get("operator").(string)
+	query := fmt.Sprintf("%s(%s):%s:%s{%s} %s %s %s", timeAggr,
+		timeWindow,
+		spaceAggr,
+		metric,
+		tagsParsed,
+		keys,
+		operator,
+		threshold)
+
+	log.Print(fmt.Sprintf("[DEBUG] submitting query: %s", query))
+
+	o := datadog.Options{
+		NotifyNoData:     d.Get("notify_no_data").(bool),
+		NoDataTimeframe:  d.Get("no_data_timeframe").(int),
+		RenotifyInterval: d.Get("renotify_interval").(int),
+		Thresholds:       thresholds,
+	}
+
+	m := datadog.Monitor{
+		Type:    "metric alert",
+		Query:   query,
+		Name:    name,
+		Message: message,
+		Options: o,
+	}
+
+	return &m
+}
+
+// resourceDatadogMetricAlertCreate creates a monitor.
+func resourceDatadogMetricAlertCreate(d *schema.ResourceData, meta interface{}) error {
+
+	m := buildMetricAlertStruct(d)
+	if err := monitorCreator(d, meta, m); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// resourceDatadogMetricAlertUpdate updates a monitor.
+func resourceDatadogMetricAlertUpdate(d *schema.ResourceData, meta interface{}) error {
+	log.Printf("[DEBUG] running update.")
+
+	m := buildMetricAlertStruct(d)
+	if err := monitorUpdater(d, meta, m); err != nil {
+		return err
+	}
+
+	return nil
+}