stackdriver: contrib.go.opencensus.io/exporter/stackdriver Index | Examples | Files | Directories

package stackdriver

import "contrib.go.opencensus.io/exporter/stackdriver"

Package stackdriver contains the OpenCensus exporters for Stackdriver Monitoring and Stackdriver Tracing.

This exporter can be used to send metrics to Stackdriver Monitoring and traces to Stackdriver trace.

The package uses Application Default Credentials to authenticate by default. See: https://developers.google.com/identity/protocols/application-default-credentials

Alternatively, pass the authentication options in both the MonitoringClientOptions and the TraceClientOptions fields of Options.

Stackdriver Monitoring

This exporter support exporting OpenCensus views to Stackdriver Monitoring. Each registered view becomes a metric in Stackdriver Monitoring, with the tags becoming labels.

The aggregation function determines the metric kind: LastValue aggregations generate Gauge metrics and all other aggregations generate Cumulative metrics.

In order to be able to push your stats to Stackdriver Monitoring, you must:

1. Create a Cloud project: https://support.google.com/cloud/answer/6251787?hl=en
2. Enable billing: https://support.google.com/cloud/answer/6288653#new-billing
3. Enable the Stackdriver Monitoring API: https://console.cloud.google.com/apis/dashboard

These steps enable the API but don't require that your app is hosted on Google Cloud Platform.

Stackdriver Trace

This exporter supports exporting Trace Spans to Stackdriver Trace. It also supports the Google "Cloud Trace" propagation format header.

Code:

exporter, err := stackdriver.NewExporter(stackdriver.Options{ProjectID: "google-project-id"})
if err != nil {
    log.Fatal(err)
}

// Export to Stackdriver Monitoring.
view.RegisterExporter(exporter)

// Subscribe views to see stats in Stackdriver Monitoring.
if err := view.Register(
    ochttp.ClientLatencyView,
    ochttp.ClientResponseBytesView,
); err != nil {
    log.Fatal(err)
}

// Export to Stackdriver Trace.
trace.RegisterExporter(exporter)

// Automatically add a Stackdriver trace header to outgoing requests:
client := &http.Client{
    Transport: &ochttp.Transport{
        Propagation: &propagation.HTTPFormat{},
    },
}
_ = client // use client

// All outgoing requests from client will include a Stackdriver Trace header.
// See the ochttp package for how to handle incoming requests.

Code:


// This example shows how to set up a Stackdriver exporter suitable for
// monitoring a GKE container.

instanceID, err := metadata.InstanceID()
if err != nil {
    log.Println("Error getting instance ID:", err)
    instanceID = "unknown"
}
zone, err := metadata.Zone()
if err != nil {
    log.Println("Error getting zone:", err)
    zone = "unknown"
}

exporter, err := stackdriver.NewExporter(stackdriver.Options{
    ProjectID: "google-project-id",
    // Set a MonitoredResource that represents a GKE container.
    Resource: &monitoredres.MonitoredResource{
        Type: "gke_container",
        Labels: map[string]string{
            "project_id":   "google-project-id",
            "cluster_name": "my-cluster-name",
            "instance_id":  instanceID,
            "zone":         zone,

            // See: https://kubernetes.io/docs/tasks/inject-data-application/environment-variable-expose-pod-information/
            "namespace_id":   os.Getenv("MY_POD_NAMESPACE"),
            "pod_id":         os.Getenv("MY_POD_NAME"),
            "container_name": os.Getenv("MY_CONTAINER_NAME"),
        },
    },
    // Set DefaultMonitoringLabels to avoid getting the default "opencensus_task"
    // label. For this to be valid, this exporter should be the only writer
    // to the metrics against this gke_container MonitoredResource. In this case,
    // it means you should only have one process writing to Stackdriver from this
    // container.
    DefaultMonitoringLabels: &stackdriver.Labels{},
})
if err != nil {
    log.Fatal(err)
}

// Register so that views are exported.
view.RegisterExporter(exporter)

Index

Examples

Package Files

label.go metrics.go metrics_proto.go metrics_test_utils.go resource.go sanitize.go stackdriver.go stats.go trace.go trace_proto.go

func DefaultMapResource Uses

func DefaultMapResource(res *resource.Resource) *monitoredrespb.MonitoredResource

type Exporter Uses

type Exporter struct {
    // contains filtered or unexported fields
}

Exporter is a stats and trace exporter that uploads data to Stackdriver.

You can create a single Exporter and register it as both a trace exporter (to export to Stackdriver Trace) and a stats exporter (to integrate with Stackdriver Monitoring).

func NewExporter Uses

func NewExporter(o Options) (*Exporter, error)

NewExporter creates a new Exporter that implements both stats.Exporter and trace.Exporter.

func (*Exporter) ExportMetrics Uses

func (e *Exporter) ExportMetrics(ctx context.Context, metrics []*metricdata.Metric) error

ExportMetrics exports OpenCensus Metrics to Stackdriver Monitoring

func (*Exporter) ExportMetricsProto Uses

func (e *Exporter) ExportMetricsProto(ctx context.Context, node *commonpb.Node, rsc *resourcepb.Resource, metrics []*metricspb.Metric) error

ExportMetricsProto exports OpenCensus Metrics Proto to Stackdriver Monitoring.

func (*Exporter) ExportSpan Uses

func (e *Exporter) ExportSpan(sd *trace.SpanData)

ExportSpan exports a SpanData to Stackdriver Trace.

func (*Exporter) ExportView Uses

func (e *Exporter) ExportView(vd *view.Data)

ExportView exports to the Stackdriver Monitoring if view data has one or more rows.

func (*Exporter) Flush Uses

func (e *Exporter) Flush()

Flush waits for exported data to be uploaded.

This is useful if your program is ending and you do not want to lose recent stats or spans.

func (*Exporter) StartMetricsExporter Uses

func (e *Exporter) StartMetricsExporter() error

StartMetricsExporter starts exporter by creating an interval reader that reads metrics from all registered producers at set interval and exports them. Use StopMetricsExporter to stop exporting metrics. Previously, it required registering exporter to export stats collected by opencensus.

exporter := stackdriver.NewExporter(stackdriver.Option{})
view.RegisterExporter(exporter)

Now, it requires to call StartMetricsExporter() to export stats and metrics collected by opencensus.

exporter := stackdriver.NewExporter(stackdriver.Option{})
exporter.StartMetricsExporter()
defer exporter.StopMetricsExporter()

Both approach should not be used simultaenously. Otherwise it may result into unknown behavior. Previous approach continues to work as before but will not report newly define metrics such as gauges.

func (*Exporter) StopMetricsExporter Uses

func (e *Exporter) StopMetricsExporter()

StopMetricsExporter stops exporter from exporting metrics.

type Labels Uses

type Labels struct {
    // contains filtered or unexported fields
}

Labels represents a set of Stackdriver Monitoring labels.

func (*Labels) Set Uses

func (labels *Labels) Set(key, value, description string)

Set stores a label with the given key, value and description, overwriting any previous values with the given key.

type Options Uses

type Options struct {
    // ProjectID is the identifier of the Stackdriver
    // project the user is uploading the stats data to.
    // If not set, this will default to your "Application Default Credentials".
    // For details see: https://developers.google.com/accounts/docs/application-default-credentials.
    //
    // It will be used in the project_id label of a Stackdriver monitored
    // resource if the resource does not inherently belong to a specific
    // project, e.g. on-premise resource like k8s_container or generic_task.
    ProjectID string

    // Location is the identifier of the GCP or AWS cloud region/zone in which
    // the data for a resource is stored.
    // If not set, it will default to the location provided by the metadata server.
    //
    // It will be used in the location label of a Stackdriver monitored resource
    // if the resource does not inherently belong to a specific project, e.g.
    // on-premise resource like k8s_container or generic_task.
    Location string

    // OnError is the hook to be called when there is
    // an error uploading the stats or tracing data.
    // If no custom hook is set, errors are logged.
    // Optional.
    OnError func(err error)

    // MonitoringClientOptions are additional options to be passed
    // to the underlying Stackdriver Monitoring API client.
    // Optional.
    MonitoringClientOptions []option.ClientOption

    // TraceClientOptions are additional options to be passed
    // to the underlying Stackdriver Trace API client.
    // Optional.
    TraceClientOptions []option.ClientOption

    // BundleDelayThreshold determines the max amount of time
    // the exporter can wait before uploading view data or trace spans to
    // the backend.
    // Optional.
    BundleDelayThreshold time.Duration

    // BundleCountThreshold determines how many view data events or trace spans
    // can be buffered before batch uploading them to the backend.
    // Optional.
    BundleCountThreshold int

    // TraceSpansBufferMaxBytes is the maximum size (in bytes) of spans that
    // will be buffered in memory before being dropped.
    //
    // If unset, a default of 8MB will be used.
    TraceSpansBufferMaxBytes int

    // Resource sets the MonitoredResource against which all views will be
    // recorded by this exporter.
    //
    // All Stackdriver metrics created by this exporter are custom metrics,
    // so only a limited number of MonitoredResource types are supported, see:
    // https://cloud.google.com/monitoring/custom-metrics/creating-metrics#which-resource
    //
    // An important consideration when setting the Resource here is that
    // Stackdriver Monitoring only allows a single writer per
    // TimeSeries, see: https://cloud.google.com/monitoring/api/v3/metrics-details#intro-time-series
    // A TimeSeries is uniquely defined by the metric type name
    // (constructed from the view name and the MetricPrefix), the Resource field,
    // and the set of label key/value pairs (in OpenCensus terminology: tag).
    //
    // If no custom Resource is set, a default MonitoredResource
    // with type global and no resource labels will be used. If you explicitly
    // set this field, you may also want to set custom DefaultMonitoringLabels.
    //
    // Deprecated: Use MonitoredResource instead.
    Resource *monitoredrespb.MonitoredResource

    // MonitoredResource sets the MonitoredResource against which all views will be
    // recorded by this exporter.
    //
    // All Stackdriver metrics created by this exporter are custom metrics,
    // so only a limited number of MonitoredResource types are supported, see:
    // https://cloud.google.com/monitoring/custom-metrics/creating-metrics#which-resource
    //
    // An important consideration when setting the MonitoredResource here is that
    // Stackdriver Monitoring only allows a single writer per
    // TimeSeries, see: https://cloud.google.com/monitoring/api/v3/metrics-details#intro-time-series
    // A TimeSeries is uniquely defined by the metric type name
    // (constructed from the view name and the MetricPrefix), the MonitoredResource field,
    // and the set of label key/value pairs (in OpenCensus terminology: tag).
    //
    // If no custom MonitoredResource is set AND if Resource is also not set then
    // a default MonitoredResource with type global and no resource labels will be used.
    // If you explicitly set this field, you may also want to set custom DefaultMonitoringLabels.
    //
    // This field replaces Resource field. If this is set then it will override the
    // Resource field.
    // Optional, but encouraged.
    MonitoredResource monitoredresource.Interface

    // ResourceDetector provides a hook to discover arbitrary resource information.
    //
    // The translation function provided in MapResource must be able to conver the
    // the resource information to a Stackdriver monitored resource.
    //
    // If this field is unset, resource type and tags will automatically be discovered through
    // the OC_RESOURCE_TYPE and OC_RESOURCE_LABELS environment variables.
    ResourceDetector resource.Detector

    // MapResource converts a OpenCensus resource to a Stackdriver monitored resource.
    //
    // If this field is unset, DefaultMapResource will be used which encodes a set of default
    // conversions from auto-detected resources to well-known Stackdriver monitored resources.
    MapResource func(*resource.Resource) *monitoredrespb.MonitoredResource

    // MetricPrefix overrides the prefix of a Stackdriver metric display names.
    // Optional. If unset defaults to "OpenCensus/".
    // Deprecated: Provide GetMetricDisplayName to change the display name of
    // the metric.
    // If GetMetricDisplayName is non-nil, this option is ignored.
    MetricPrefix string

    // GetMetricDisplayName allows customizing the display name for the metric
    // associated with the given view. By default it will be:
    //   MetricPrefix + view.Name
    GetMetricDisplayName func(view *view.View) string

    // GetMetricType allows customizing the metric type for the given view.
    // By default, it will be:
    //   "custom.googleapis.com/opencensus/" + view.Name
    //
    // See: https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.metricDescriptors#MetricDescriptor
    GetMetricType func(view *view.View) string

    // DefaultTraceAttributes will be appended to every span that is exported to
    // Stackdriver Trace.
    DefaultTraceAttributes map[string]interface{}

    // DefaultMonitoringLabels are labels added to every metric created by this
    // exporter in Stackdriver Monitoring.
    //
    // If unset, this defaults to a single label with key "opencensus_task" and
    // value "go-<pid>@<hostname>". This default ensures that the set of labels
    // together with the default Resource (global) are unique to this
    // process, as required by Stackdriver Monitoring.
    //
    // If you set DefaultMonitoringLabels, make sure that the Resource field
    // together with these labels is unique to the
    // current process. This is to ensure that there is only a single writer to
    // each TimeSeries in Stackdriver.
    //
    // Set this to &Labels{} (a pointer to an empty Labels) to avoid getting the
    // default "opencensus_task" label. You should only do this if you know that
    // the Resource you set uniquely identifies this Go process.
    DefaultMonitoringLabels *Labels

    // Context allows you to provide a custom context for API calls.
    //
    // This context will be used several times: first, to create Stackdriver
    // trace and metric clients, and then every time a new batch of traces or
    // stats needs to be uploaded.
    //
    // Do not set a timeout on this context. Instead, set the Timeout option.
    //
    // If unset, context.Background() will be used.
    Context context.Context

    // Timeout for all API calls. If not set, defaults to 5 seconds.
    Timeout time.Duration

    // GetMonitoredResource may be provided to supply the details of the
    // monitored resource dynamically based on the tags associated with each
    // data point. Most users will not need to set this, but should instead
    // set the MonitoredResource field.
    //
    // GetMonitoredResource may add or remove tags by returning a new set of
    // tags. It is safe for the function to mutate its argument and return it.
    //
    // See the documentation on the MonitoredResource field for guidance on the
    // interaction between monitored resources and labels.
    //
    // The MonitoredResource field is ignored if this field is set to a non-nil
    // value.
    GetMonitoredResource func(*view.View, []tag.Tag) ([]tag.Tag, monitoredresource.Interface)

    // ReportingInterval sets the interval between reporting metrics.
    // If it is set to zero then default value is used.
    ReportingInterval time.Duration
}

Options contains options for configuring the exporter.

Directories

PathSynopsis
examples/statsCommand stackdriver is an example program that collects data for video size.
internal/testpbPackage testpb is a generated protocol buffer package.
monitoredresource
propagationPackage propagation implement X-Cloud-Trace-Context header propagation used by Google Cloud products.

Package stackdriver imports 46 packages (graph) and is imported by 38 packages. Updated 2019-04-23. Refresh now. Tools for package owners.