package errorreporting

Import Path
	cloud.google.com/go/errorreporting (on go.dev)

Dependency Relation
	imports 14 packages, and imported by 5 packages

Involved Source Files

	   d➜ errors.go
		Package errorreporting is a Google Stackdriver Error Reporting library.

		Any provided stacktraces must match the format produced by https://golang.org/pkg/runtime/#Stack
		or as per https://cloud.google.com/error-reporting/reference/rest/v1beta1/projects.events/report#ReportedErrorEvent
		for language specific stacktrace formats.

		This package is still experimental and subject to change.

		See https://cloud.google.com/error-reporting/ for more information.
Code Examples

	
		package main
		
		import (
			"context"
			"errors"
			"log"
		
			"cloud.google.com/go/errorreporting"
		)
		
		func main() {
			// Create the client.
			ctx := context.Background()
			ec, err := errorreporting.NewClient(ctx, "my-gcp-project", errorreporting.Config{
				ServiceName:    "myservice",
				ServiceVersion: "v1.0",
			})
			if err != nil {
				// TODO: handle error
			}
			defer func() {
				if err := ec.Close(); err != nil {
					log.Printf("failed to report errors to Stackdriver: %v", err)
				}
			}()
		
			// Report an error.
			err = doSomething()
			if err != nil {
				ec.Report(errorreporting.Entry{
					Error: err,
				})
			}
		}
		
		func doSomething() error {
			return errors.New("something went wrong")
		}


Package-Level Type Names (total 4, in which 3 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Client (struct)
		Client represents a Google Cloud Error Reporting client.

		Fields (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			apiClient client
			bundler *bundler.Bundler
			onErrorFn func(err error)
			projectName string
			serviceContext *pb.ServiceContext
		Methods (total 6, in which 4 are exported)
			(*T) Close() error
				Close calls Flush, then closes any resources held by the client.
				Close should be called when the client is no longer needed.

			(*T) Flush()
				Flush blocks until all currently buffered error reports are sent.

				If any errors occurred since the last call to Flush, or the
				creation of the client if this is the first call, then Flush reports the
				error via the Config.OnError handler.

			(*T) Report(e Entry)
				Report writes an error report. It doesn't block. Errors in
				writing the error report can be handled via Config.OnError.

			(*T) ReportSync(ctx context.Context, e Entry) error
				ReportSync writes an error report. It blocks until the entry is written.

			/* 2 unexporteds ... *//* 2 unexporteds: */
			(*T) newRequest(e Entry) *pb.ReportErrorEventRequest
			(*T) onError(err error)
		Implements (at least 3, all are exported)
			*T : golang.org/x/pkgsite/internal/middleware.Reporter
			*T : io.Closer
			*T : net/http.Flusher
		As Outputs Of (at least 2, both are exported)
			func NewClient(ctx context.Context, projectID string, cfg Config, opts ...option.ClientOption) (*Client, error)
			func golang.org/x/pkgsite/cmd/internal/cmdconfig.ReportingClient(ctx context.Context, cfg *config.Config) *Client
		As Inputs Of (at least 2, both are exported)
			func golang.org/x/pkgsite/cmd/internal/cmdconfig.Experimenter(ctx context.Context, cfg *config.Config, getter middleware.ExperimentGetter, reportingClient *Client) *middleware.Experimenter
			func golang.org/x/pkgsite/internal/derrors.SetReportingClient(c *Client)
		As Types Of (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			  var golang.org/x/pkgsite/internal/derrors.repClient *errorreporting.Client

	 type Config (struct)
		Config is additional configuration for Client.

		Fields (total 3, all are exported)
			OnError func(err error)
				OnError is the function to call if any background
				tasks errored. By default, errors are logged.

			ServiceName string
				ServiceName identifies the running program and is included in the error reports.
				Optional.

			ServiceVersion string
				ServiceVersion identifies the version of the running program and is
				included in the error reports.
				Optional.

		As Inputs Of (at least one exported)
			func NewClient(ctx context.Context, projectID string, cfg Config, opts ...option.ClientOption) (*Client, error)

	 type Entry (struct)
		Entry holds information about the reported error.

		Fields (total 4, all are exported)
			Error error
			Req *http.Request
				// if error is associated with a request.

			Stack []byte
				Stack specifies the stacktrace and call sequence correlated with
				the error. Stack's content must match the format specified by
				https://cloud.google.com/error-reporting/reference/rest/v1beta1/projects.events/report#ReportedErrorEvent.message
				or at least for Go programs, it must match the format produced
				by https://golang.org/pkg/runtime/debug/#Stack.

				If Stack is blank, the result of runtime.Stack will be used instead.

			User string
				// an identifier for the user affected by the error

		As Inputs Of (at least 4, in which 3 are exported)
			func (*Client).Report(e Entry)
			func (*Client).ReportSync(ctx context.Context, e Entry) error
			func golang.org/x/pkgsite/internal/middleware.Reporter.Report(Entry)
			/* at least one unexported ... *//* at least one unexported: */
			func (*Client).newRequest(e Entry) *pb.ReportErrorEventRequest

	/* one unexported ... *//* one unexported: */
	 type client (interface)

		Methods (total 2, both are exported)
			( T) Close() error
			( T) ReportErrorEvent(ctx context.Context, req *pb.ReportErrorEventRequest, opts ...gax.CallOption) (*pb.ReportErrorEventResponse, error)
		Implemented By (at least one exported)
			*cloud.google.com/go/errorreporting/apiv1beta1.ReportErrorsClient
		Implements (at least one exported)
			 T : io.Closer


Package-Level Functions (total 2, in which 1 are exported)

	 func NewClient(ctx context.Context, projectID string, cfg Config, opts ...option.ClientOption) (*Client, error)
		NewClient returns a new error reporting client. Generally you will want
		to create a client on program initialization and use it through the lifetime
		of the process.

	/* one unexported ... *//* one unexported: */
	 func chopStack(s []byte) string
		chopStack trims a stack trace so that the function which panics or calls
		Report is first.


Package-Level Variables (only one, which is unexported)

	/* one unexported ... *//* one unexported: */
	  var newClient func(ctx context.Context, opts ...option.ClientOption) (client, error)

The pages are generated with Golds v0.3.2-preview. (GOOS=darwin GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.