Package log

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")
		break
	}
	if err != nil {
		log.Errorf(c, "Failed to retrieve next log: %v", err)
		break
	}
	log.Infof(c, "Saw record %v", record)
}

Variables

Done is returned when a query iteration has completed.

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

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 ¶

AppLog represents a single application-level log.

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

type Query ¶

Query defines a logs 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
}

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 ¶

Record contains all the information for a single web request.

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
}

type Result ¶

Result represents the result of a query.

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

func (*Result) Next ¶

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

Next returns the next log record,