add GDrive provider support (#118)

* GDrive provider support
* More reliable basedir ownership
* Fix mimetype

vendor/cloud.google.com/go/logging/logging.go

@@ -0,0 +1,814 @@
+// Copyright 2016 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// API/gRPC features intentionally missing from this client:
+// - You cannot have the server pick the time of the entry. This client
+//   always sends a time.
+// - There is no way to provide a protocol buffer payload.
+// - No support for the "partial success" feature when writing log entries.
+
+// TODO(jba): test whether forward-slash characters in the log ID must be URL-encoded.
+// These features are missing now, but will likely be added:
+// - There is no way to specify CallOptions.
+
+package logging
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"log"
+	"math"
+	"net/http"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"cloud.google.com/go/compute/metadata"
+	"cloud.google.com/go/internal/version"
+	vkit "cloud.google.com/go/logging/apiv2"
+	"cloud.google.com/go/logging/internal"
+	"github.com/golang/protobuf/proto"
+	"github.com/golang/protobuf/ptypes"
+	structpb "github.com/golang/protobuf/ptypes/struct"
+	tspb "github.com/golang/protobuf/ptypes/timestamp"
+	"golang.org/x/net/context"
+	"google.golang.org/api/option"
+	"google.golang.org/api/support/bundler"
+	mrpb "google.golang.org/genproto/googleapis/api/monitoredres"
+	logtypepb "google.golang.org/genproto/googleapis/logging/type"
+	logpb "google.golang.org/genproto/googleapis/logging/v2"
+)
+
+const (
+	// Scope for reading from the logging service.
+	ReadScope = "https://www.googleapis.com/auth/logging.read"
+
+	// Scope for writing to the logging service.
+	WriteScope = "https://www.googleapis.com/auth/logging.write"
+
+	// Scope for administrative actions on the logging service.
+	AdminScope = "https://www.googleapis.com/auth/logging.admin"
+)
+
+const (
+	// defaultErrorCapacity is the capacity of the channel used to deliver
+	// errors to the OnError function.
+	defaultErrorCapacity = 10
+
+	// DefaultDelayThreshold is the default value for the DelayThreshold LoggerOption.
+	DefaultDelayThreshold = time.Second
+
+	// DefaultEntryCountThreshold is the default value for the EntryCountThreshold LoggerOption.
+	DefaultEntryCountThreshold = 1000
+
+	// DefaultEntryByteThreshold is the default value for the EntryByteThreshold LoggerOption.
+	DefaultEntryByteThreshold = 1 << 20 // 1MiB
+
+	// DefaultBufferedByteLimit is the default value for the BufferedByteLimit LoggerOption.
+	DefaultBufferedByteLimit = 1 << 30 // 1GiB
+
+	// defaultWriteTimeout is the timeout for the underlying write API calls. As
+	// write API calls are not idempotent, they are not retried on timeout. This
+	// timeout is to allow clients to degrade gracefully if underlying logging
+	// service is temporarily impaired for some reason.
+	defaultWriteTimeout = 10 * time.Minute
+)
+
+// For testing:
+var now = time.Now
+
+// ErrOverflow signals that the number of buffered entries for a Logger
+// exceeds its BufferLimit.
+var ErrOverflow = bundler.ErrOverflow
+
+// ErrOversizedEntry signals that an entry's size exceeds the maximum number of
+// bytes that will be sent in a single call to the logging service.
+var ErrOversizedEntry = bundler.ErrOversizedItem
+
+// Client is a Logging client. A Client is associated with a single Cloud project.
+type Client struct {
+	client  *vkit.Client   // client for the logging service
+	parent  string         // e.g. "projects/proj-id"
+	errc    chan error     // should be buffered to minimize dropped errors
+	donec   chan struct{}  // closed on Client.Close to close Logger bundlers
+	loggers sync.WaitGroup // so we can wait for loggers to close
+	closed  bool
+
+	mu      sync.Mutex
+	nErrs   int   // number of errors we saw
+	lastErr error // last error we saw
+
+	// OnError is called when an error occurs in a call to Log or Flush. The
+	// error may be due to an invalid Entry, an overflow because BufferLimit
+	// was reached (in which case the error will be ErrOverflow) or an error
+	// communicating with the logging service. OnError is called with errors
+	// from all Loggers. It is never called concurrently. OnError is expected
+	// to return quickly; if errors occur while OnError is running, some may
+	// not be reported. The default behavior is to call log.Printf.
+	//
+	// This field should be set only once, before any method of Client is called.
+	OnError func(err error)
+}
+
+// NewClient returns a new logging client associated with the provided parent.
+// A parent can take any of the following forms:
+//    projects/PROJECT_ID
+//    folders/FOLDER_ID
+//    billingAccounts/ACCOUNT_ID
+//    organizations/ORG_ID
+// for backwards compatibility, a string with no '/' is also allowed and is interpreted
+// as a project ID.
+//
+// By default NewClient uses WriteScope. To use a different scope, call
+// NewClient using a WithScopes option (see https://godoc.org/google.golang.org/api/option#WithScopes).
+func NewClient(ctx context.Context, parent string, opts ...option.ClientOption) (*Client, error) {
+	if !strings.ContainsRune(parent, '/') {
+		parent = "projects/" + parent
+	}
+	opts = append([]option.ClientOption{
+		option.WithEndpoint(internal.ProdAddr),
+		option.WithScopes(WriteScope),
+	}, opts...)
+	c, err := vkit.NewClient(ctx, opts...)
+	if err != nil {
+		return nil, err
+	}
+	c.SetGoogleClientInfo("gccl", version.Repo)
+	client := &Client{
+		client:  c,
+		parent:  parent,
+		errc:    make(chan error, defaultErrorCapacity), // create a small buffer for errors
+		donec:   make(chan struct{}),
+		OnError: func(e error) { log.Printf("logging client: %v", e) },
+	}
+	// Call the user's function synchronously, to make life easier for them.
+	go func() {
+		for err := range client.errc {
+			// This reference to OnError is memory-safe if the user sets OnError before
+			// calling any client methods. The reference happens before the first read from
+			// client.errc, which happens before the first write to client.errc, which
+			// happens before any call, which happens before the user sets OnError.
+			if fn := client.OnError; fn != nil {
+				fn(err)
+			} else {
+				log.Printf("logging (parent %q): %v", parent, err)
+			}
+		}
+	}()
+	return client, nil
+}
+
+var unixZeroTimestamp *tspb.Timestamp
+
+func init() {
+	var err error
+	unixZeroTimestamp, err = ptypes.TimestampProto(time.Unix(0, 0))
+	if err != nil {
+		panic(err)
+	}
+}
+
+// Ping reports whether the client's connection to the logging service and the
+// authentication configuration are valid. To accomplish this, Ping writes a
+// log entry "ping" to a log named "ping".
+func (c *Client) Ping(ctx context.Context) error {
+	ent := &logpb.LogEntry{
+		Payload:   &logpb.LogEntry_TextPayload{TextPayload: "ping"},
+		Timestamp: unixZeroTimestamp, // Identical timestamps and insert IDs are both
+		InsertId:  "ping",            // necessary for the service to dedup these entries.
+	}
+	_, err := c.client.WriteLogEntries(ctx, &logpb.WriteLogEntriesRequest{
+		LogName:  internal.LogPath(c.parent, "ping"),
+		Resource: monitoredResource(c.parent),
+		Entries:  []*logpb.LogEntry{ent},
+	})
+	return err
+}
+
+// error puts the error on the client's error channel
+// without blocking, and records summary error info.
+func (c *Client) error(err error) {
+	select {
+	case c.errc <- err:
+	default:
+	}
+	c.mu.Lock()
+	c.lastErr = err
+	c.nErrs++
+	c.mu.Unlock()
+}
+
+func (c *Client) extractErrorInfo() error {
+	var err error
+	c.mu.Lock()
+	if c.lastErr != nil {
+		err = fmt.Errorf("saw %d errors; last: %v", c.nErrs, c.lastErr)
+		c.nErrs = 0
+		c.lastErr = nil
+	}
+	c.mu.Unlock()
+	return err
+}
+
+// A Logger is used to write log messages to a single log. It can be configured
+// with a log ID, common monitored resource, and a set of common labels.
+type Logger struct {
+	client     *Client
+	logName    string // "projects/{projectID}/logs/{logID}"
+	stdLoggers map[Severity]*log.Logger
+	bundler    *bundler.Bundler
+
+	// Options
+	commonResource *mrpb.MonitoredResource
+	commonLabels   map[string]string
+	writeTimeout   time.Duration
+}
+
+// A LoggerOption is a configuration option for a Logger.
+type LoggerOption interface {
+	set(*Logger)
+}
+
+// CommonResource sets the monitored resource associated with all log entries
+// written from a Logger. If not provided, the resource is automatically
+// detected based on the running environment.  This value can be overridden
+// per-entry by setting an Entry's Resource field.
+func CommonResource(r *mrpb.MonitoredResource) LoggerOption { return commonResource{r} }
+
+type commonResource struct{ *mrpb.MonitoredResource }
+
+func (r commonResource) set(l *Logger) { l.commonResource = r.MonitoredResource }
+
+var detectedResource struct {
+	pb   *mrpb.MonitoredResource
+	once sync.Once
+}
+
+func detectResource() *mrpb.MonitoredResource {
+	detectedResource.once.Do(func() {
+		if !metadata.OnGCE() {
+			return
+		}
+		projectID, err := metadata.ProjectID()
+		if err != nil {
+			return
+		}
+		id, err := metadata.InstanceID()
+		if err != nil {
+			return
+		}
+		zone, err := metadata.Zone()
+		if err != nil {
+			return
+		}
+		detectedResource.pb = &mrpb.MonitoredResource{
+			Type: "gce_instance",
+			Labels: map[string]string{
+				"project_id":  projectID,
+				"instance_id": id,
+				"zone":        zone,
+			},
+		}
+	})
+	return detectedResource.pb
+}
+
+var resourceInfo = map[string]struct{ rtype, label string }{
+	"organizations":   {"organization", "organization_id"},
+	"folders":         {"folder", "folder_id"},
+	"projects":        {"project", "project_id"},
+	"billingAccounts": {"billing_account", "account_id"},
+}
+
+func monitoredResource(parent string) *mrpb.MonitoredResource {
+	parts := strings.SplitN(parent, "/", 2)
+	if len(parts) != 2 {
+		return globalResource(parent)
+	}
+	info, ok := resourceInfo[parts[0]]
+	if !ok {
+		return globalResource(parts[1])
+	}
+	return &mrpb.MonitoredResource{
+		Type:   info.rtype,
+		Labels: map[string]string{info.label: parts[1]},
+	}
+}
+
+func globalResource(projectID string) *mrpb.MonitoredResource {
+	return &mrpb.MonitoredResource{
+		Type: "global",
+		Labels: map[string]string{
+			"project_id": projectID,
+		},
+	}
+}
+
+// CommonLabels are labels that apply to all log entries written from a Logger,
+// so that you don't have to repeat them in each log entry's Labels field. If
+// any of the log entries contains a (key, value) with the same key that is in
+// CommonLabels, then the entry's (key, value) overrides the one in
+// CommonLabels.
+func CommonLabels(m map[string]string) LoggerOption { return commonLabels(m) }
+
+type commonLabels map[string]string
+
+func (c commonLabels) set(l *Logger) { l.commonLabels = c }
+
+// ConcurrentWriteLimit determines how many goroutines will send log entries to the
+// underlying service. The default is 1. Set ConcurrentWriteLimit to a higher value to
+// increase throughput.
+func ConcurrentWriteLimit(n int) LoggerOption { return concurrentWriteLimit(n) }
+
+type concurrentWriteLimit int
+
+func (c concurrentWriteLimit) set(l *Logger) { l.bundler.HandlerLimit = int(c) }
+
+// DelayThreshold is the maximum amount of time that an entry should remain
+// buffered in memory before a call to the logging service is triggered. Larger
+// values of DelayThreshold will generally result in fewer calls to the logging
+// service, while increasing the risk that log entries will be lost if the
+// process crashes.
+// The default is DefaultDelayThreshold.
+func DelayThreshold(d time.Duration) LoggerOption { return delayThreshold(d) }
+
+type delayThreshold time.Duration
+
+func (d delayThreshold) set(l *Logger) { l.bundler.DelayThreshold = time.Duration(d) }
+
+// EntryCountThreshold is the maximum number of entries that will be buffered
+// in memory before a call to the logging service is triggered. Larger values
+// will generally result in fewer calls to the logging service, while
+// increasing both memory consumption and the risk that log entries will be
+// lost if the process crashes.
+// The default is DefaultEntryCountThreshold.
+func EntryCountThreshold(n int) LoggerOption { return entryCountThreshold(n) }
+
+type entryCountThreshold int
+
+func (e entryCountThreshold) set(l *Logger) { l.bundler.BundleCountThreshold = int(e) }
+
+// EntryByteThreshold is the maximum number of bytes of entries that will be
+// buffered in memory before a call to the logging service is triggered. See
+// EntryCountThreshold for a discussion of the tradeoffs involved in setting
+// this option.
+// The default is DefaultEntryByteThreshold.
+func EntryByteThreshold(n int) LoggerOption { return entryByteThreshold(n) }
+
+type entryByteThreshold int
+
+func (e entryByteThreshold) set(l *Logger) { l.bundler.BundleByteThreshold = int(e) }
+
+// EntryByteLimit is the maximum number of bytes of entries that will be sent
+// in a single call to the logging service. ErrOversizedEntry is returned if an
+// entry exceeds EntryByteLimit. This option limits the size of a single RPC
+// payload, to account for network or service issues with large RPCs. If
+// EntryByteLimit is smaller than EntryByteThreshold, the latter has no effect.
+// The default is zero, meaning there is no limit.
+func EntryByteLimit(n int) LoggerOption { return entryByteLimit(n) }
+
+type entryByteLimit int
+
+func (e entryByteLimit) set(l *Logger) { l.bundler.BundleByteLimit = int(e) }
+
+// BufferedByteLimit is the maximum number of bytes that the Logger will keep
+// in memory before returning ErrOverflow. This option limits the total memory
+// consumption of the Logger (but note that each Logger has its own, separate
+// limit). It is possible to reach BufferedByteLimit even if it is larger than
+// EntryByteThreshold or EntryByteLimit, because calls triggered by the latter
+// two options may be enqueued (and hence occupying memory) while new log
+// entries are being added.
+// The default is DefaultBufferedByteLimit.
+func BufferedByteLimit(n int) LoggerOption { return bufferedByteLimit(n) }
+
+type bufferedByteLimit int
+
+func (b bufferedByteLimit) set(l *Logger) { l.bundler.BufferedByteLimit = int(b) }
+
+// Logger returns a Logger that will write entries with the given log ID, such as
+// "syslog". A log ID must be less than 512 characters long and can only
+// include the following characters: upper and lower case alphanumeric
+// characters: [A-Za-z0-9]; and punctuation characters: forward-slash,
+// underscore, hyphen, and period.
+func (c *Client) Logger(logID string, opts ...LoggerOption) *Logger {
+	r := detectResource()
+	if r == nil {
+		r = monitoredResource(c.parent)
+	}
+	l := &Logger{
+		client:         c,
+		logName:        internal.LogPath(c.parent, logID),
+		commonResource: r,
+	}
+	l.bundler = bundler.NewBundler(&logpb.LogEntry{}, func(entries interface{}) {
+		l.writeLogEntries(entries.([]*logpb.LogEntry))
+	})
+	l.bundler.DelayThreshold = DefaultDelayThreshold
+	l.bundler.BundleCountThreshold = DefaultEntryCountThreshold
+	l.bundler.BundleByteThreshold = DefaultEntryByteThreshold
+	l.bundler.BufferedByteLimit = DefaultBufferedByteLimit
+	for _, opt := range opts {
+		opt.set(l)
+	}
+	l.stdLoggers = map[Severity]*log.Logger{}
+	for s := range severityName {
+		l.stdLoggers[s] = log.New(severityWriter{l, s}, "", 0)
+	}
+
+	c.loggers.Add(1)
+	// Start a goroutine that cleans up the bundler, its channel
+	// and the writer goroutines when the client is closed.
+	go func() {
+		defer c.loggers.Done()
+		<-c.donec
+		l.bundler.Flush()
+	}()
+	return l
+}
+
+type severityWriter struct {
+	l *Logger
+	s Severity
+}
+
+func (w severityWriter) Write(p []byte) (n int, err error) {
+	w.l.Log(Entry{
+		Severity: w.s,
+		Payload:  string(p),
+	})
+	return len(p), nil
+}
+
+// Close waits for all opened loggers to be flushed and closes the client.
+func (c *Client) Close() error {
+	if c.closed {
+		return nil
+	}
+	close(c.donec)   // close Logger bundlers
+	c.loggers.Wait() // wait for all bundlers to flush and close
+	// Now there can be no more errors.
+	close(c.errc) // terminate error goroutine
+	// Prefer errors arising from logging to the error returned from Close.
+	err := c.extractErrorInfo()
+	err2 := c.client.Close()
+	if err == nil {
+		err = err2
+	}
+	c.closed = true
+	return err
+}
+
+// Severity is the severity of the event described in a log entry. These
+// guideline severity levels are ordered, with numerically smaller levels
+// treated as less severe than numerically larger levels.
+type Severity int
+
+const (
+	// Default means the log entry has no assigned severity level.
+	Default = Severity(logtypepb.LogSeverity_DEFAULT)
+	// Debug means debug or trace information.
+	Debug = Severity(logtypepb.LogSeverity_DEBUG)
+	// Info means routine information, such as ongoing status or performance.
+	Info = Severity(logtypepb.LogSeverity_INFO)
+	// Notice means normal but significant events, such as start up, shut down, or configuration.
+	Notice = Severity(logtypepb.LogSeverity_NOTICE)
+	// Warning means events that might cause problems.
+	Warning = Severity(logtypepb.LogSeverity_WARNING)
+	// Error means events that are likely to cause problems.
+	Error = Severity(logtypepb.LogSeverity_ERROR)
+	// Critical means events that cause more severe problems or brief outages.
+	Critical = Severity(logtypepb.LogSeverity_CRITICAL)
+	// Alert means a person must take an action immediately.
+	Alert = Severity(logtypepb.LogSeverity_ALERT)
+	// Emergency means one or more systems are unusable.
+	Emergency = Severity(logtypepb.LogSeverity_EMERGENCY)
+)
+
+var severityName = map[Severity]string{
+	Default:   "Default",
+	Debug:     "Debug",
+	Info:      "Info",
+	Notice:    "Notice",
+	Warning:   "Warning",
+	Error:     "Error",
+	Critical:  "Critical",
+	Alert:     "Alert",
+	Emergency: "Emergency",
+}
+
+// String converts a severity level to a string.
+func (v Severity) String() string {
+	// same as proto.EnumName
+	s, ok := severityName[v]
+	if ok {
+		return s
+	}
+	return strconv.Itoa(int(v))
+}
+
+// ParseSeverity returns the Severity whose name equals s, ignoring case. It
+// returns Default if no Severity matches.
+func ParseSeverity(s string) Severity {
+	sl := strings.ToLower(s)
+	for sev, name := range severityName {
+		if strings.ToLower(name) == sl {
+			return sev
+		}
+	}
+	return Default
+}
+
+// Entry is a log entry.
+// See https://cloud.google.com/logging/docs/view/logs_index for more about entries.
+type Entry struct {
+	// Timestamp is the time of the entry. If zero, the current time is used.
+	Timestamp time.Time
+
+	// Severity is the entry's severity level.
+	// The zero value is Default.
+	Severity Severity
+
+	// Payload must be either a string, or something that marshals via the
+	// encoding/json package to a JSON object (and not any other type of JSON value).
+	Payload interface{}
+
+	// Labels optionally specifies key/value labels for the log entry.
+	// The Logger.Log method takes ownership of this map. See Logger.CommonLabels
+	// for more about labels.
+	Labels map[string]string
+
+	// InsertID is a unique ID for the log entry. If you provide this field,
+	// the logging service considers other log entries in the same log with the
+	// same ID as duplicates which can be removed. If omitted, the logging
+	// service will generate a unique ID for this log entry. Note that because
+	// this client retries RPCs automatically, it is possible (though unlikely)
+	// that an Entry without an InsertID will be written more than once.
+	InsertID string
+
+	// HTTPRequest optionally specifies metadata about the HTTP request
+	// associated with this log entry, if applicable. It is optional.
+	HTTPRequest *HTTPRequest
+
+	// Operation optionally provides information about an operation associated
+	// with the log entry, if applicable.
+	Operation *logpb.LogEntryOperation
+
+	// LogName is the full log name, in the form
+	// "projects/{ProjectID}/logs/{LogID}". It is set by the client when
+	// reading entries. It is an error to set it when writing entries.
+	LogName string
+
+	// Resource is the monitored resource associated with the entry.
+	Resource *mrpb.MonitoredResource
+
+	// Trace is the resource name of the trace associated with the log entry,
+	// if any. If it contains a relative resource name, the name is assumed to
+	// be relative to //tracing.googleapis.com.
+	Trace string
+}
+
+// HTTPRequest contains an http.Request as well as additional
+// information about the request and its response.
+type HTTPRequest struct {
+	// Request is the http.Request passed to the handler.
+	Request *http.Request
+
+	// RequestSize is the size of the HTTP request message in bytes, including
+	// the request headers and the request body.
+	RequestSize int64
+
+	// Status is the response code indicating the status of the response.
+	// Examples: 200, 404.
+	Status int
+
+	// ResponseSize is the size of the HTTP response message sent back to the client, in bytes,
+	// including the response headers and the response body.
+	ResponseSize int64
+
+	// Latency is the request processing latency on the server, from the time the request was
+	// received until the response was sent.
+	Latency time.Duration
+
+	// LocalIP is the IP address (IPv4 or IPv6) of the origin server that the request
+	// was sent to.
+	LocalIP string
+
+	// RemoteIP is the IP address (IPv4 or IPv6) of the client that issued the
+	// HTTP request. Examples: "192.168.1.1", "FE80::0202:B3FF:FE1E:8329".
+	RemoteIP string
+
+	// CacheHit reports whether an entity was served from cache (with or without
+	// validation).
+	CacheHit bool
+
+	// CacheValidatedWithOriginServer reports whether the response was
+	// validated with the origin server before being served from cache. This
+	// field is only meaningful if CacheHit is true.
+	CacheValidatedWithOriginServer bool
+}
+
+func fromHTTPRequest(r *HTTPRequest) *logtypepb.HttpRequest {
+	if r == nil {
+		return nil
+	}
+	if r.Request == nil {
+		panic("HTTPRequest must have a non-nil Request")
+	}
+	u := *r.Request.URL
+	u.Fragment = ""
+	pb := &logtypepb.HttpRequest{
+		RequestMethod:                  r.Request.Method,
+		RequestUrl:                     u.String(),
+		RequestSize:                    r.RequestSize,
+		Status:                         int32(r.Status),
+		ResponseSize:                   r.ResponseSize,
+		UserAgent:                      r.Request.UserAgent(),
+		ServerIp:                       r.LocalIP,
+		RemoteIp:                       r.RemoteIP, // TODO(jba): attempt to parse http.Request.RemoteAddr?
+		Referer:                        r.Request.Referer(),
+		CacheHit:                       r.CacheHit,
+		CacheValidatedWithOriginServer: r.CacheValidatedWithOriginServer,
+	}
+	if r.Latency != 0 {
+		pb.Latency = ptypes.DurationProto(r.Latency)
+	}
+	return pb
+}
+
+// toProtoStruct converts v, which must marshal into a JSON object,
+// into a Google Struct proto.
+func toProtoStruct(v interface{}) (*structpb.Struct, error) {
+	// Fast path: if v is already a *structpb.Struct, nothing to do.
+	if s, ok := v.(*structpb.Struct); ok {
+		return s, nil
+	}
+	// v is a Go value that supports JSON marshalling. We want a Struct
+	// protobuf. Some day we may have a more direct way to get there, but right
+	// now the only way is to marshal the Go value to JSON, unmarshal into a
+	// map, and then build the Struct proto from the map.
+	var jb []byte
+	var err error
+	if raw, ok := v.(json.RawMessage); ok { // needed for Go 1.7 and below
+		jb = []byte(raw)
+	} else {
+		jb, err = json.Marshal(v)
+		if err != nil {
+			return nil, fmt.Errorf("logging: json.Marshal: %v", err)
+		}
+	}
+	var m map[string]interface{}
+	err = json.Unmarshal(jb, &m)
+	if err != nil {
+		return nil, fmt.Errorf("logging: json.Unmarshal: %v", err)
+	}
+	return jsonMapToProtoStruct(m), nil
+}
+
+func jsonMapToProtoStruct(m map[string]interface{}) *structpb.Struct {
+	fields := map[string]*structpb.Value{}
+	for k, v := range m {
+		fields[k] = jsonValueToStructValue(v)
+	}
+	return &structpb.Struct{Fields: fields}
+}
+
+func jsonValueToStructValue(v interface{}) *structpb.Value {
+	switch x := v.(type) {
+	case bool:
+		return &structpb.Value{Kind: &structpb.Value_BoolValue{BoolValue: x}}
+	case float64:
+		return &structpb.Value{Kind: &structpb.Value_NumberValue{NumberValue: x}}
+	case string:
+		return &structpb.Value{Kind: &structpb.Value_StringValue{StringValue: x}}
+	case nil:
+		return &structpb.Value{Kind: &structpb.Value_NullValue{}}
+	case map[string]interface{}:
+		return &structpb.Value{Kind: &structpb.Value_StructValue{StructValue: jsonMapToProtoStruct(x)}}
+	case []interface{}:
+		var vals []*structpb.Value
+		for _, e := range x {
+			vals = append(vals, jsonValueToStructValue(e))
+		}
+		return &structpb.Value{Kind: &structpb.Value_ListValue{ListValue: &structpb.ListValue{Values: vals}}}
+	default:
+		panic(fmt.Sprintf("bad type %T for JSON value", v))
+	}
+}
+
+// LogSync logs the Entry synchronously without any buffering. Because LogSync is slow
+// and will block, it is intended primarily for debugging or critical errors.
+// Prefer Log for most uses.
+// TODO(jba): come up with a better name (LogNow?) or eliminate.
+func (l *Logger) LogSync(ctx context.Context, e Entry) error {
+	ent, err := toLogEntry(e)
+	if err != nil {
+		return err
+	}
+	_, err = l.client.client.WriteLogEntries(ctx, &logpb.WriteLogEntriesRequest{
+		LogName:  l.logName,
+		Resource: l.commonResource,
+		Labels:   l.commonLabels,
+		Entries:  []*logpb.LogEntry{ent},
+	})
+	return err
+}
+
+// Log buffers the Entry for output to the logging service. It never blocks.
+func (l *Logger) Log(e Entry) {
+	ent, err := toLogEntry(e)
+	if err != nil {
+		l.client.error(err)
+		return
+	}
+	if err := l.bundler.Add(ent, proto.Size(ent)); err != nil {
+		l.client.error(err)
+	}
+}
+
+// Flush blocks until all currently buffered log entries are sent.
+//
+// If any errors occurred since the last call to Flush from any Logger, or the
+// creation of the client if this is the first call, then Flush returns a non-nil
+// error with summary information about the errors. This information is unlikely to
+// be actionable. For more accurate error reporting, set Client.OnError.
+func (l *Logger) Flush() error {
+	l.bundler.Flush()
+	return l.client.extractErrorInfo()
+}
+
+func (l *Logger) writeLogEntries(entries []*logpb.LogEntry) {
+	req := &logpb.WriteLogEntriesRequest{
+		LogName:  l.logName,
+		Resource: l.commonResource,
+		Labels:   l.commonLabels,
+		Entries:  entries,
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), defaultWriteTimeout)
+	defer cancel()
+	_, err := l.client.client.WriteLogEntries(ctx, req)
+	if err != nil {
+		l.client.error(err)
+	}
+}
+
+// StandardLogger returns a *log.Logger for the provided severity.
+//
+// This method is cheap. A single log.Logger is pre-allocated for each
+// severity level in each Logger. Callers may mutate the returned log.Logger
+// (for example by calling SetFlags or SetPrefix).
+func (l *Logger) StandardLogger(s Severity) *log.Logger { return l.stdLoggers[s] }
+
+func trunc32(i int) int32 {
+	if i > math.MaxInt32 {
+		i = math.MaxInt32
+	}
+	return int32(i)
+}
+
+func toLogEntry(e Entry) (*logpb.LogEntry, error) {
+	if e.LogName != "" {
+		return nil, errors.New("logging: Entry.LogName should be not be set when writing")
+	}
+	t := e.Timestamp
+	if t.IsZero() {
+		t = now()
+	}
+	ts, err := ptypes.TimestampProto(t)
+	if err != nil {
+		return nil, err
+	}
+	ent := &logpb.LogEntry{
+		Timestamp:   ts,
+		Severity:    logtypepb.LogSeverity(e.Severity),
+		InsertId:    e.InsertID,
+		HttpRequest: fromHTTPRequest(e.HTTPRequest),
+		Operation:   e.Operation,
+		Labels:      e.Labels,
+		Trace:       e.Trace,
+		Resource:    e.Resource,
+	}
+	switch p := e.Payload.(type) {
+	case string:
+		ent.Payload = &logpb.LogEntry_TextPayload{TextPayload: p}
+	default:
+		s, err := toProtoStruct(p)
+		if err != nil {
+			return nil, err
+		}
+		ent.Payload = &logpb.LogEntry_JsonPayload{JsonPayload: s}
+	}
+	return ent, nil
+}