tracing.go

package main

import (
	"context"
	"fmt"
	"log"
	"net/http"
	"os"
	"time"

	ocagent "contrib.go.opencensus.io/exporter/ocagent"
	"github.com/Azure/azure-sdk-for-go/services/preview/dns/mgmt/2018-03-01-preview/dns"
	"github.com/Azure/go-autorest/autorest/azure/auth"
	"github.com/Azure/go-autorest/autorest/to"
	"github.com/Azure/go-autorest/tracing"
	openzipkin "github.com/openzipkin/zipkin-go"
	zipkinHTTP "github.com/openzipkin/zipkin-go/reporter/http"
	"go.opencensus.io/exporter/prometheus"
	"go.opencensus.io/exporter/zipkin"
	"go.opencensus.io/stats/view"
	"go.opencensus.io/trace"
)

const (
	subID      = "7127e532-e730-40dd-acda-0ca1105c1e55"
	rg         = "vladdbGoTest"
	zoneName   = "vladdbtest.com"
	rrCount    = 100
	deleteRR   = false
	getRR      = false
	deleteZone = true
)

func main() {
	initZipkin()
	//	initProm()
	//initTracing()
	doAzureStuff()
}

func doAzureStuff() {
	zonesClient := dns.NewZonesClient(subID)
	agentEndpoint := fmt.Sprintf("%s:%d", ocagent.DefaultAgentHost, ocagent.DefaultAgentPort)
	tracing.EnableWithAIForwarding(agentEndpoint)
	recordsClient := dns.NewRecordSetsClient(subID)
	authorizer, _ := auth.NewAuthorizerFromEnvironment()
	zonesClient.Authorizer = authorizer
	recordsClient.Authorizer = authorizer

	ctx, span := trace.StartSpan(context.Background(), "doAzureStuff", trace.WithSampler(trace.AlwaysSample()))
	defer span.End()

	executeZonesActions(ctx, zonesClient)
	//for {
	executeRecordSetsActions(ctx, recordsClient)
	//	time.Sleep(10 * time.Second)
	//}

	if deleteZone {
		cleanupZones(ctx, zonesClient)
		time.Sleep(10 * time.Second)
	}
}

func executeZonesActions(ctx context.Context, zonesClient dns.ZonesClient) {
	ctx, span := trace.StartSpan(ctx, "executeZonesActions")
	defer span.End()
	zone, _ := zonesClient.CreateOrUpdate(ctx, rg, zoneName, dns.Zone{
		Location: to.StringPtr("global"),
	}, "", "")

	zoneGet, _ := zonesClient.Get(ctx, rg, *zone.Name)

	if *zoneGet.Name == *zone.Name {
		fmt.Println("Zones names are good")
	}
}

func cleanupZones(ctx context.Context, zonesClient dns.ZonesClient) {
	ctx, span := trace.StartSpan(ctx, "cleanupZones")
	defer span.End()
	future, _ := zonesClient.Delete(ctx, rg, zoneName, "")
	//done, _ := future.Done(zonesClient)

	done := future.WaitForCompletion(ctx, zonesClient.Client)

	if done == nil {
		fmt.Println("Delete is Done immediatley:", done, future.Status())
	}

	fmt.Println("Delete finished:", done)
}
func executeRecordSetsActions(ctx context.Context, recordsClient dns.RecordSetsClient) {
	ctx, span := trace.StartSpan(ctx, "executeRecordSetsActions")
	defer span.End()
	executeRRCreate(ctx, recordsClient)
	if getRR {
		executeRRGet(ctx, recordsClient)
	}
	if deleteRR {
		executeRRDelete(ctx, recordsClient)
	}
}

func executeRRCreate(ctx context.Context, recordsClient dns.RecordSetsClient) {
	ctx, span := trace.StartSpan(ctx, "executeRRCreate")
	defer span.End()
	for i := 0; i < rrCount; i++ {
		rr, _ := recordsClient.CreateOrUpdate(ctx, rg, zoneName, fmt.Sprintf("rr%d", i), dns.CNAME, dns.RecordSet{
			RecordSetProperties: &dns.RecordSetProperties{
				TTL: to.Int64Ptr(3600),
				CnameRecord: &dns.CnameRecord{
					Cname: to.StringPtr("vladdbCname"),
				},
			},
		},
			"", // if-match
			"", // if-none-match)
		)

		fmt.Println("Create RR: name is ", *rr.Name)
	}
}

func executeRRGet(ctx context.Context, recordsClient dns.RecordSetsClient) {
	ctx, span := trace.StartSpan(ctx, "executeRRGet")
	defer span.End()
	for i := 0; i < rrCount; i++ {
		rr, _ := recordsClient.Get(ctx, rg, zoneName, fmt.Sprintf("rr%d", i), dns.CNAME)
		fmt.Println("Get RR: name is ", *rr.Name)
	}
}

func executeRRDelete(ctx context.Context, recordsClient dns.RecordSetsClient) {
	ctx, span := trace.StartSpan(ctx, "executeRRDelete")
	defer span.End()
	for i := 0; i < rrCount; i++ {
		rrName := fmt.Sprintf("rr%d", i)
		_, _ = recordsClient.Delete(ctx, rg, zoneName, rrName, dns.CNAME, "")
		fmt.Println("Delete RR: name is %s", rrName)
	}
}

func initTracing() {
	agentEndpoint := os.Getenv("OCAGENT_TRACE_EXPORTER_ENDPOINT")

	if len(agentEndpoint) == 0 {
		agentEndpoint = fmt.Sprintf("%s:%d", ocagent.DefaultAgentHost, ocagent.DefaultAgentPort)
	}

	exporter, err := ocagent.NewExporter(ocagent.WithInsecure(), ocagent.WithAddress(agentEndpoint))

	if err != nil {
		log.Printf("Failed to create the agent exporter: %v", err)
	}

	trace.RegisterExporter(exporter)
}

func initZipkin() {
	localEndpoint, err := openzipkin.NewEndpoint("vladdbTestAppGosdkService", "192.168.1.5:5454")
	if err != nil {
		log.Fatalf("Failed to create the local zipkinEndpoint: %v", err)
	}
	reporter := zipkinHTTP.NewReporter("http://localhost:9411/api/v2/spans")
	ze := zipkin.NewExporter(reporter, localEndpoint)
	// Register the Zipkin exporter.
	// This step is needed so that traces can be exported.
	trace.RegisterExporter(ze)
}

func initProm() {
	// Create the Prometheus exporter.
	pe, err := prometheus.NewExporter(prometheus.Options{
		Namespace: "vladdbTestAppGosdkService",
	})
	if err != nil {
		log.Fatalf("Failed to create the Prometheus stats exporter: %v", err)
	}
	// Register the Prometheus exporter.
	view.RegisterExporter(pe)

	// Now finally run the Prometheus exporter as a scrape endpoint.
	go func() {
		mux := http.NewServeMux()
		mux.Handle("/metrics", pe)
		if err := http.ListenAndServe(":8888", mux); err != nil {
			log.Fatalf("Failed to run Prometheus scrape endpoint: %v", err)
		}
	}()
}