Package log provides the means of writing and querying an application's logs from within an App Engine application.


    c := appengine.NewContext(r)
    query := &log.Query{
    	AppLogs:  true,
    	Versions: []string{"1"},
    for results := query.Run(c); ; {
    	record, err := results.Next()
    	if err == log.Done {
    		log.Infof(c, "Done processing results")
    	if err != nil {
    		log.Errorf(c, "Failed to retrieve next log: %v", err)
    	log.Infof(c, "Saw record %v", record)



    This section is empty.


    View Source
    var Done = errors.New("log: query has no more results")

      Done is returned when a query iteration has completed.


      func Criticalf

      func Criticalf(ctx context.Context, format string, args ...interface{})

        Criticalf is like Debugf, but at Critical level.

        func Debugf

        func Debugf(ctx context.Context, format string, args ...interface{})

          Debugf formats its arguments according to the format, analogous to fmt.Printf, and records the text as a log message at Debug level. The message will be associated with the request linked with the provided context.

          func Errorf

          func Errorf(ctx context.Context, format string, args ...interface{})

            Errorf is like Debugf, but at Error level.

            func Infof

            func Infof(ctx context.Context, format string, args ...interface{})

              Infof is like Debugf, but at Info level.

              func Warningf

              func Warningf(ctx context.Context, format string, args ...interface{})

                Warningf is like Debugf, but at Warning level.


                type AppLog

                type AppLog struct {
                	Time    time.Time
                	Level   int
                	Message string

                  AppLog represents a single application-level log.

                  type Query

                  type Query struct {
                  	// Start time specifies the earliest log to return (inclusive).
                  	StartTime time.Time
                  	// End time specifies the latest log to return (exclusive).
                  	EndTime time.Time
                  	// Offset specifies a position within the log stream to resume reading from,
                  	// and should come from a previously returned Record's field of the same name.
                  	Offset []byte
                  	// Incomplete controls whether active (incomplete) requests should be included.
                  	Incomplete bool
                  	// AppLogs indicates if application-level logs should be included.
                  	AppLogs bool
                  	// ApplyMinLevel indicates if MinLevel should be used to filter results.
                  	ApplyMinLevel bool
                  	// If ApplyMinLevel is true, only logs for requests with at least one
                  	// application log of MinLevel or higher will be returned.
                  	MinLevel int
                  	// Versions is the major version IDs whose logs should be retrieved.
                  	// Logs for specific modules can be retrieved by the specifying versions
                  	// in the form "module:version"; the default module is used if no module
                  	// is specified.
                  	Versions []string
                  	// A list of requests to search for instead of a time-based scan. Cannot be
                  	// combined with filtering options such as StartTime, EndTime, Offset,
                  	// Incomplete, ApplyMinLevel, or Versions.
                  	RequestIDs []string

                    Query defines a logs query.

                    func (*Query) Run

                    func (params *Query) Run(c context.Context) *Result

                      Run starts a query for log records, which contain request and application level log information.

                      type Record

                      type Record struct {
                      	AppID            string
                      	ModuleID         string
                      	VersionID        string
                      	RequestID        []byte
                      	IP               string
                      	Nickname         string
                      	AppEngineRelease string
                      	// The time when this request started.
                      	StartTime time.Time
                      	// The time when this request finished.
                      	EndTime time.Time
                      	// Opaque cursor into the result stream.
                      	Offset []byte
                      	// The time required to process the request.
                      	Latency     time.Duration
                      	MCycles     int64
                      	Method      string
                      	Resource    string
                      	HTTPVersion string
                      	Status      int32
                      	// The size of the request sent back to the client, in bytes.
                      	ResponseSize int64
                      	Referrer     string
                      	UserAgent    string
                      	URLMapEntry  string
                      	Combined     string
                      	Host         string
                      	// The estimated cost of this request, in dollars.
                      	Cost              float64
                      	TaskQueueName     string
                      	TaskName          string
                      	WasLoadingRequest bool
                      	PendingTime       time.Duration
                      	Finished          bool
                      	AppLogs           []AppLog
                      	// Mostly-unique identifier for the instance that handled the request if available.
                      	InstanceID string

                        Record contains all the information for a single web request.

                        type Result

                        type Result struct {
                        	// contains filtered or unexported fields

                          Result represents the result of a query.

                          func (*Result) Next

                          func (qr *Result) Next() (*Record, error)

                            Next returns the next log record,

                            Source Files