diff --git a/logging/go.mod b/logging/go.mod
index 98e3438..180c0a8 100644
--- a/logging/go.mod
+++ b/logging/go.mod
@@ -13,4 +13,5 @@
 	google.golang.org/api v0.48.0
 	google.golang.org/genproto v0.0.0-20210607140030-00d4fb20b1ae
 	google.golang.org/grpc v1.38.0
+	google.golang.org/protobuf v1.26.0
 )
diff --git a/logging/internal/common.go b/logging/internal/common.go
index c5788fe..0f2bc98 100644
--- a/logging/internal/common.go
+++ b/logging/internal/common.go
@@ -15,13 +15,22 @@
 package internal
 
 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
+	"regexp"
 	"strings"
+	"unicode/utf8"
+
+	"google.golang.org/protobuf/types/known/structpb"
 )
 
 const (
 	// ProdAddr is the production address.
 	ProdAddr = "logging.googleapis.com:443"
+
+	// TraceHeader is the HTTP header trace information is stored in.
+	TraceHeader = "X-Cloud-Trace-Context"
 )
 
 // LogPath creates a formatted path from a parent and a logID.
@@ -39,3 +48,116 @@
 	logID := path[start:]
 	return strings.Replace(logID, "%2F", "/", -1)
 }
+
+var reCloudTraceContext = regexp.MustCompile(
+	// Matches on "TRACE_ID"
+	`([a-f\d]+)?` +
+		// Matches on "/SPAN_ID"
+		`(?:/([a-f\d]+))?` +
+		// Matches on ";0=TRACE_TRUE"
+		`(?:;o=(\d))?`)
+
+// DeconstructXCloudTraceContext extracts trace information from the trace
+// header.
+//
+// As per the format described at https://cloud.google.com/trace/docs/setup#force-trace
+//    "X-Cloud-Trace-Context: TRACE_ID/SPAN_ID;o=TRACE_TRUE"
+// for example:
+//    "X-Cloud-Trace-Context: 105445aa7843bc8bf206b120001000/1;o=1"
+//
+// We expect:
+//   * traceID (optional): 			"105445aa7843bc8bf206b120001000"
+//   * spanID (optional):       	"1"
+//   * traceSampled (optional): 	true
+func DeconstructXCloudTraceContext(s string) (traceID, spanID string, traceSampled bool) {
+	matches := reCloudTraceContext.FindStringSubmatch(s)
+
+	traceID, spanID, traceSampled = matches[1], matches[2], matches[3] == "1"
+
+	if spanID == "0" {
+		spanID = ""
+	}
+
+	return
+}
+
+// FixUTF8 is a helper that fixes an invalid UTF-8 string by replacing
+// invalid UTF-8 runes with the Unicode replacement character (U+FFFD).
+// See Issue https://github.com/googleapis/google-cloud-go/issues/1383.
+func FixUTF8(s string) string {
+	if utf8.ValidString(s) {
+		return s
+	}
+
+	// Otherwise time to build the sequence.
+	buf := new(bytes.Buffer)
+	buf.Grow(len(s))
+	for _, r := range s {
+		if utf8.ValidRune(r) {
+			buf.WriteRune(r)
+		} else {
+			buf.WriteRune('\uFFFD')
+		}
+	}
+	return buf.String()
+}
+
+// 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:
+		return &structpb.Value{Kind: &structpb.Value_NullValue{}}
+	}
+}
diff --git a/logging/internal/common_test.go b/logging/internal/common_test.go
new file mode 100644
index 0000000..fbcc265
--- /dev/null
+++ b/logging/internal/common_test.go
@@ -0,0 +1,81 @@
+// Copyright 2021 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.
+
+package internal
+
+import (
+	"testing"
+
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/types/known/structpb"
+)
+
+func TestToProtoStruct(t *testing.T) {
+	v := struct {
+		Foo string                 `json:"foo"`
+		Bar int                    `json:"bar,omitempty"`
+		Baz []float64              `json:"baz"`
+		Moo map[string]interface{} `json:"moo"`
+	}{
+		Foo: "foovalue",
+		Baz: []float64{1.1},
+		Moo: map[string]interface{}{
+			"a": 1,
+			"b": "two",
+			"c": true,
+		},
+	}
+
+	got, err := ToProtoStruct(v)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := &structpb.Struct{
+		Fields: map[string]*structpb.Value{
+			"foo": {Kind: &structpb.Value_StringValue{StringValue: v.Foo}},
+			"baz": {Kind: &structpb.Value_ListValue{ListValue: &structpb.ListValue{Values: []*structpb.Value{
+				{Kind: &structpb.Value_NumberValue{NumberValue: 1.1}},
+			}}}},
+			"moo": {Kind: &structpb.Value_StructValue{
+				StructValue: &structpb.Struct{
+					Fields: map[string]*structpb.Value{
+						"a": {Kind: &structpb.Value_NumberValue{NumberValue: 1}},
+						"b": {Kind: &structpb.Value_StringValue{StringValue: "two"}},
+						"c": {Kind: &structpb.Value_BoolValue{BoolValue: true}},
+					},
+				},
+			}},
+		},
+	}
+	if !proto.Equal(got, want) {
+		t.Errorf("got  %+v\nwant %+v", got, want)
+	}
+
+	// Non-structs should fail to convert.
+	for v := range []interface{}{3, "foo", []int{1, 2, 3}} {
+		_, err := ToProtoStruct(v)
+		if err == nil {
+			t.Errorf("%v: got nil, want error", v)
+		}
+	}
+
+	// Test fast path.
+	got, err = ToProtoStruct(want)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != want {
+		t.Error("got and want should be identical, but are not")
+	}
+}
diff --git a/logging/jsonlog/example_test.go b/logging/jsonlog/example_test.go
new file mode 100644
index 0000000..0832def
--- /dev/null
+++ b/logging/jsonlog/example_test.go
@@ -0,0 +1,67 @@
+// Copyright 2021 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.
+
+package jsonlog_test
+
+import (
+	"io"
+	"net/http"
+	"os"
+
+	"cloud.google.com/go/logging/jsonlog"
+)
+
+func ExampleNewLogger() {
+	l, err := jsonlog.NewLogger("projects/PROJECT_ID")
+	if err != nil {
+		// TODO: handle error.
+	}
+	l.Infof("Hello World!")
+}
+
+func ExampLogger_WithRequest() {
+	var req *http.Request
+	l, err := jsonlog.NewLogger("projects/PROJECT_ID")
+	if err != nil {
+		// TODO: handle error.
+	}
+	// Create a Logger with additional information pulled from the current
+	// request context.
+	l = l.WithRequest(req)
+	l.Infof("Hello World!")
+}
+
+func ExampleLogger_WithLabels() {
+	l, err := jsonlog.NewLogger("projects/PROJECT_ID")
+	if err != nil {
+		// TODO: handle error.
+	}
+	l.Infof("Hello World!")
+
+	// Create a logger that always provides additional context by adding labels
+	// to all logged messages.
+	l2 := l.WithLabels(map[string]string{"foo": "bar"})
+	l2.Infof("Hello World, with more context!")
+}
+
+func ExampleWithWriter_multiwriter() {
+	// Create a new writer that also logs messages to a second location
+	w := io.MultiWriter(os.Stderr, os.Stdout)
+	l, err := jsonlog.NewLogger("projects/PROJECT_ID", jsonlog.WithWriter(w))
+	if err != nil {
+		// TODO: handle error.
+	}
+	l.Infof("Hello World!")
+	// Output: {"message":"Hello World!","severity":"INFO"}
+}
diff --git a/logging/jsonlog/jsonlog.go b/logging/jsonlog/jsonlog.go
new file mode 100644
index 0000000..2904c2b
--- /dev/null
+++ b/logging/jsonlog/jsonlog.go
@@ -0,0 +1,346 @@
+// Copyright 2021 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.
+
+// Package jsonlog provides a Logger that logs structured JSON to Stderr by
+// default. When used on the various Cloud Compute environments (Cloud Run,
+// Cloud Functions, GKE, etc.) these JSON messages will be parsed by the Cloud
+// Logging agent and transformed into a message format that mirrors that of the
+// Cloud Logging API.
+package jsonlog
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"strings"
+	"time"
+
+	"cloud.google.com/go/logging"
+	"cloud.google.com/go/logging/internal"
+	logtypepb "google.golang.org/genproto/googleapis/logging/type"
+	logpb "google.golang.org/genproto/googleapis/logging/v2"
+	"google.golang.org/protobuf/encoding/protojson"
+)
+
+const (
+	debugSeverity     = "DEBUG"
+	infoSeverity      = "INFO"
+	noticeSeverity    = "NOTICE"
+	warnSeverity      = "WARNING"
+	errorSeverity     = "ERROR"
+	criticalSeverity  = "CRITICAL"
+	alertSeverity     = "ALERT"
+	emergencySeverity = "EMERGENCY"
+)
+
+// NewLogger creates a Logger that logs structured JSON to Stderr. The value of
+// parent must be in the format of:
+//    projects/PROJECT_ID
+//    folders/FOLDER_ID
+//    billingAccounts/ACCOUNT_ID
+//    organizations/ORG_ID
+func NewLogger(parent string, opts ...LoggerOption) (*Logger, error) {
+	if err := validateParent(parent); err != nil {
+		return nil, err
+	}
+	l := &Logger{
+		w:      os.Stderr,
+		parent: parent,
+	}
+	for _, opt := range opts {
+		opt.set(l)
+	}
+	return l, nil
+}
+
+// Logger is used for logging JSON entries.
+type Logger struct {
+	w       io.Writer
+	now     func() time.Time
+	errhook func(error)
+	parent  string
+
+	// read-only fields
+	labels  map[string]string
+	req     *logtypepb.HttpRequest
+	traceID string
+	sampled bool
+	spanID  string
+}
+
+// copy does a shallow copy of the logger. Individual fields should not be
+// modified but replaced.
+func (l *Logger) copy() *Logger {
+	return &Logger{
+		w:       l.w,
+		now:     l.now,
+		errhook: l.errhook,
+		parent:  l.parent,
+		labels:  l.labels,
+		req:     l.req,
+		traceID: l.traceID,
+		sampled: l.sampled,
+		spanID:  l.spanID,
+	}
+}
+
+// Debugf is a convenience method for writing an Entry with a Debug Severity
+// and the provided formatted message.
+func (l *Logger) Debugf(format string, a ...interface{}) {
+	e := entry{
+		Message:  fmt.Sprintf(format, a...),
+		Severity: debugSeverity,
+	}
+	l.log(e)
+}
+
+// Infof is a convenience method for writing an Entry with a Debug Severity
+// and the provided formatted message.
+func (l *Logger) Infof(format string, a ...interface{}) {
+	e := entry{
+		Message:  fmt.Sprintf(format, a...),
+		Severity: infoSeverity,
+	}
+	l.log(e)
+}
+
+// Noticef is a convenience method for writing an Entry with a Debug Severity
+// and the provided formatted message.
+func (l *Logger) Noticef(format string, a ...interface{}) {
+	e := entry{
+		Message:  fmt.Sprintf(format, a...),
+		Severity: noticeSeverity,
+	}
+	l.log(e)
+}
+
+// Warnf is a convenience method for writing an Entry with a Debug Severity
+// and the provided formatted message.
+func (l *Logger) Warnf(format string, a ...interface{}) {
+	e := entry{
+		Message:  fmt.Sprintf(format, a...),
+		Severity: warnSeverity,
+	}
+	l.log(e)
+}
+
+// Errorf is a convenience method for writing an Entry with a Debug Severity
+// and the provided formatted message.
+func (l *Logger) Errorf(format string, a ...interface{}) {
+	e := entry{
+		Message:  fmt.Sprintf(format, a...),
+		Severity: errorSeverity,
+	}
+	l.log(e)
+}
+
+// Criticalf is a convenience method for writing an Entry with a Debug Severity
+// and the provided formatted message.
+func (l *Logger) Criticalf(format string, a ...interface{}) {
+	e := entry{
+		Message:  fmt.Sprintf(format, a...),
+		Severity: criticalSeverity,
+	}
+	l.log(e)
+}
+
+// Alertf is a convenience method for writing an Entry with a Debug Severity
+// and the provided formatted message.
+func (l *Logger) Alertf(format string, a ...interface{}) {
+	e := entry{
+		Message:  fmt.Sprintf(format, a...),
+		Severity: alertSeverity,
+	}
+	l.log(e)
+}
+
+// Emergencyf is a convenience method for writing an Entry with a Debug Severity
+// and the provided formatted message.
+func (l *Logger) Emergencyf(format string, a ...interface{}) {
+	e := entry{
+		Message:  fmt.Sprintf(format, a...),
+		Severity: emergencySeverity,
+	}
+	l.log(e)
+}
+
+// Log an Entry. Note that not all of the fields in entry will used when
+// writting the log message, only those that are mentioned
+// https://cloud.google.com/logging/docs/structured-logging will be logged.
+func (l *Logger) Log(e logging.Entry) {
+	le := entry{
+		Severity:       e.Severity.String(),
+		Labels:         e.Labels,
+		InsertID:       e.InsertID,
+		Operation:      e.Operation,
+		SourceLocation: e.SourceLocation,
+		SpanID:         e.SpanID,
+		Trace:          e.Trace,
+		TraceSampled:   e.TraceSampled,
+	}
+	if e.HTTPRequest != nil {
+		le.HTTPRequest = toLogpbHTTPRequest(e.HTTPRequest.Request)
+	}
+	if !e.Timestamp.IsZero() {
+		le.Timestamp = e.Timestamp.Format(time.RFC3339)
+	}
+	switch p := e.Payload.(type) {
+	case string:
+		le.Message = p
+	default:
+		s, err := internal.ToProtoStruct(p)
+		if err != nil {
+			if l.errhook != nil {
+				l.errhook(err)
+			}
+			return
+		}
+		b, err := protojson.Marshal(s)
+		if err != nil {
+			if l.errhook != nil {
+				l.errhook(err)
+			}
+			return
+		}
+		le.Message = string(b)
+	}
+	l.log(le)
+}
+
+func (l *Logger) log(e entry) {
+	if e.Timestamp == "" && l.now != nil {
+		e.Timestamp = l.now().Format(time.RFC3339)
+	}
+	if e.Trace == "" {
+		e.Trace = l.traceID
+	}
+	if e.SpanID == "" {
+		e.SpanID = l.spanID
+	}
+	if !e.TraceSampled {
+		e.TraceSampled = l.sampled
+	}
+	if e.HTTPRequest == nil && l.req != nil {
+		e.HTTPRequest = l.req
+	}
+	if l.labels != nil {
+		if e.Labels == nil {
+			e.Labels = l.labels
+		} else {
+			for k, v := range l.labels {
+				if _, ok := e.Labels[k]; !ok {
+					e.Labels[k] = v
+				}
+			}
+		}
+	}
+	if err := json.NewEncoder(l.w).Encode(e); err != nil && l.errhook != nil {
+		l.errhook(err)
+	}
+}
+
+// WithLabels creates a new JSONLogger based off an existing one. The labels
+// provided will be added to the loggers existing labels, replacing any
+// overlapping keys with the new values.
+func (l *Logger) WithLabels(labels map[string]string) *Logger {
+	new := l.copy()
+	newLabels := make(map[string]string, len(new.labels))
+	for k, v := range new.labels {
+		newLabels[k] = v
+	}
+	for k, v := range labels {
+		newLabels[k] = v
+	}
+	new.labels = newLabels
+	return new
+}
+
+// WithRequest creates a new JSONLogger based off an existing one with request
+// information populated. By giving a Logger a request context all logs
+// will be auto-populated with some basic information about the request as well
+// as tracing details, if included.
+func (l *Logger) WithRequest(r *http.Request) *Logger {
+	new := l.copy()
+	var req *logtypepb.HttpRequest
+	if r != nil {
+		u := *r.URL
+		req = &logtypepb.HttpRequest{
+			RequestMethod: r.Method,
+			RequestUrl:    internal.FixUTF8(u.String()),
+			UserAgent:     r.UserAgent(),
+			Referer:       r.Referer(),
+			Protocol:      r.Proto,
+		}
+		if r.Response != nil {
+			req.Status = int32(r.Response.StatusCode)
+		}
+		new.req = req
+	}
+	var traceHeader string
+	if r != nil && r.Header != nil {
+		traceHeader = r.Header.Get(internal.TraceHeader)
+	}
+	if traceHeader != "" {
+		traceID, spanID, traceSampled := internal.DeconstructXCloudTraceContext(traceHeader)
+		new.traceID = fmt.Sprintf("%s/traces/%s", new.parent, traceID)
+		new.spanID = spanID
+		new.sampled = traceSampled
+	}
+	return new
+}
+
+// validateParent checks to make sure name is in the format.
+func validateParent(parent string) error {
+	if !strings.HasPrefix(parent, "projects/") &&
+		!strings.HasPrefix(parent, "folders/") &&
+		!strings.HasPrefix(parent, "billingAccounts/") &&
+		!strings.HasPrefix(parent, "organizations/") {
+		return fmt.Errorf("jsonlog: name formatting incorrect")
+	}
+	return nil
+}
+
+// entry represents the fields of a logging.Entry that can be parsed by Logging
+// agent. To see a list of these mappings see
+// https://cloud.google.com/logging/docs/structured-logging.
+type entry struct {
+	Message        string                        `json:"message"`
+	Severity       string                        `json:"severity,omitempty"`
+	HTTPRequest    *logtypepb.HttpRequest        `json:"httpRequest,omitempty"`
+	Timestamp      string                        `json:"timestamp,omitempty"`
+	Labels         map[string]string             `json:"logging.googleapis.com/labels,omitempty"`
+	InsertID       string                        `json:"logging.googleapis.com/insertId,omitempty"`
+	Operation      *logpb.LogEntryOperation      `json:"logging.googleapis.com/operation,omitempty"`
+	SourceLocation *logpb.LogEntrySourceLocation `json:"logging.googleapis.com/sourceLocation,omitempty"`
+	SpanID         string                        `json:"logging.googleapis.com/spanId,omitempty"`
+	Trace          string                        `json:"logging.googleapis.com/trace,omitempty"`
+	TraceSampled   bool                          `json:"logging.googleapis.com/trace_sampled,omitempty"`
+}
+
+func toLogpbHTTPRequest(r *http.Request) *logtypepb.HttpRequest {
+	if r == nil {
+		return nil
+	}
+	u := *r.URL
+	return &logtypepb.HttpRequest{
+		RequestMethod: r.Method,
+		RequestUrl:    internal.FixUTF8(u.String()),
+		Status:        int32(r.Response.StatusCode),
+		UserAgent:     r.UserAgent(),
+		Referer:       r.Referer(),
+		Protocol:      r.Proto,
+	}
+}
diff --git a/logging/jsonlog/jsonlog_test.go b/logging/jsonlog/jsonlog_test.go
new file mode 100644
index 0000000..b475fde
--- /dev/null
+++ b/logging/jsonlog/jsonlog_test.go
@@ -0,0 +1,312 @@
+// Copyright 2021 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.
+
+package jsonlog
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"strings"
+	"testing"
+	"time"
+
+	"cloud.google.com/go/logging"
+	"cloud.google.com/go/logging/internal"
+	"github.com/google/go-cmp/cmp"
+	ltype "google.golang.org/genproto/googleapis/logging/type"
+)
+
+func TestLoggerLevel(t *testing.T) {
+	now := time.Date(1977, time.May, 25, 0, 0, 0, 0, time.UTC)
+	fnow := now.Format(time.RFC3339)
+	tests := []struct {
+		severity string
+		lFn      func(*Logger)
+	}{
+		{severity: debugSeverity, lFn: func(l *Logger) { l.Debugf("Hello, World!") }},
+		{severity: infoSeverity, lFn: func(l *Logger) { l.Infof("Hello, World!") }},
+		{severity: noticeSeverity, lFn: func(l *Logger) { l.Noticef("Hello, World!") }},
+		{severity: warnSeverity, lFn: func(l *Logger) { l.Warnf("Hello, World!") }},
+		{severity: errorSeverity, lFn: func(l *Logger) { l.Errorf("Hello, World!") }},
+		{severity: criticalSeverity, lFn: func(l *Logger) { l.Criticalf("Hello, World!") }},
+		{severity: alertSeverity, lFn: func(l *Logger) { l.Alertf("Hello, World!") }},
+		{severity: emergencySeverity, lFn: func(l *Logger) { l.Emergencyf("Hello, World!") }},
+	}
+	for _, tt := range tests {
+		t.Run(tt.severity, func(t *testing.T) {
+			buf := bytes.NewBuffer(nil)
+			l, err := NewLogger("projects/test")
+			if err != nil {
+				t.Fatalf("unable to create logger: %v", err)
+			}
+			l.w = buf
+			l.now = func() time.Time {
+				return now
+			}
+
+			e := &entry{
+				Message:   "Hello, World!",
+				Timestamp: fnow,
+			}
+			e.Severity = tt.severity
+			b, err := json.Marshal(e)
+			if err != nil {
+				t.Fatalf("unable to marshal: %v", err)
+			}
+			tt.lFn(l)
+			if diff := cmp.Diff(string(b), strings.TrimSpace(buf.String())); diff != "" {
+				t.Fatalf("Logger.Debugf() mismatch (-want +got):\n%s", diff)
+			}
+		})
+	}
+
+}
+
+func TestLoggerWithLabels(t *testing.T) {
+	l, err := NewLogger("projects/test/log123")
+	if err != nil {
+		t.Fatalf("unable to create logger: %v", err)
+	}
+
+	tests := []struct {
+		name           string
+		commonLabels   map[string]string
+		entryLabels    map[string]string
+		outputLabelLen int
+	}{
+		{
+			name:           "empty labels",
+			outputLabelLen: 0,
+		},
+		{
+			name:           "two common labels",
+			commonLabels:   map[string]string{"one": "foo", "two": "bar"},
+			outputLabelLen: 2,
+		},
+		{
+			name:           "two common labels and one entry",
+			commonLabels:   map[string]string{"one": "foo", "two": "bar"},
+			entryLabels:    map[string]string{"three": "baz"},
+			outputLabelLen: 3,
+		},
+		{
+			name:           "three unique labels with overlap",
+			commonLabels:   map[string]string{"one": "foo", "two": "bar", "three": "baz"},
+			entryLabels:    map[string]string{"three": "baz"},
+			outputLabelLen: 3,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			buf := bytes.NewBuffer(nil)
+			l.w = buf
+			e := entry{}
+
+			ll := l.WithLabels(tt.commonLabels)
+			ll.Log(logging.Entry{
+				Severity: logging.Info,
+				Payload:  "test",
+				Labels:   tt.entryLabels,
+			})
+			if err := json.Unmarshal(buf.Bytes(), &e); err != nil {
+				t.Fatalf("unable to unmarshal data: %v", err)
+			}
+			if len(e.Labels) != tt.outputLabelLen {
+				t.Fatalf("len(LogEntry.Labels) = %v, want %v", len(e.Labels), tt.outputLabelLen)
+			}
+		})
+	}
+}
+
+func TestLoggerWithLabels_WithOverlap(t *testing.T) {
+	l, err := NewLogger("projects/test")
+	if err != nil {
+		t.Fatalf("unable to create logger: %v", err)
+	}
+	buf := bytes.NewBuffer(nil)
+	l.w = buf
+	e := entry{}
+
+	l = l.WithLabels(map[string]string{"one": "foo", "two": "bar", "three": "baz"})
+	l.Log(logging.Entry{
+		Severity: logging.Info,
+		Payload:  "test",
+		Labels:   map[string]string{"three": "newbaz"},
+	})
+	if err := json.Unmarshal(buf.Bytes(), &e); err != nil {
+		t.Fatalf("unable to unmarshal data: %v", err)
+	}
+	if len(e.Labels) != 3 {
+		t.Fatalf("len(LogEntry.Labels) = %v, want %v", len(e.Labels), 3)
+	}
+	if e.Labels["three"] != "newbaz" {
+		t.Fatalf("le.Labels[\"three\"] = %q, want \"newbaz\"", e.Labels["three"])
+	}
+}
+
+func TestLoggerWithLabels_Twice(t *testing.T) {
+	l, err := NewLogger("projects/test/log123")
+	if err != nil {
+		t.Fatalf("unable to create logger: %v", err)
+	}
+	buf := bytes.NewBuffer(nil)
+	l.w = buf
+	e := entry{}
+
+	l = l.WithLabels(map[string]string{"one": "foo", "two": "bar"})
+	l = l.WithLabels(map[string]string{"one": "foo", "two": "newbar", "three": "baz"})
+	l.Log(logging.Entry{
+		Severity: logging.Info,
+		Payload:  "test",
+		Labels:   map[string]string{"three": "newbaz"},
+	})
+	if err := json.Unmarshal(buf.Bytes(), &e); err != nil {
+		t.Fatalf("unable to unmarshal data: %v", err)
+	}
+	if len(e.Labels) != 3 {
+		t.Fatalf("len(LogEntry.Labels) = %v, want %v", len(e.Labels), 3)
+	}
+	if e.Labels["three"] != "newbaz" {
+		t.Fatalf("le.Labels[\"three\"] = %q, want \"newbaz\"", e.Labels["three"])
+	}
+	if e.Labels["two"] != "newbar" {
+		t.Fatalf("le.Labels[\"two\"] = %q, want \"newbar\"", e.Labels["two"])
+	}
+}
+
+func TestParseName(t *testing.T) {
+	tests := []struct {
+		name        string
+		input       string
+		wantParent  string
+		wantLogName string
+		wantErr     bool
+	}{
+		{
+			name:    "valid project style",
+			input:   "projects/test",
+			wantErr: false,
+		},
+		{
+			name:    "valid folder style",
+			input:   "folders/tes",
+			wantErr: false,
+		},
+		{
+			name:    "valid billing style",
+			input:   "billingAccounts/tes",
+			wantErr: false,
+		},
+		{
+			name:    "valid org style",
+			input:   "organizations/tes",
+			wantErr: false,
+		},
+		{
+			name:    "invalid parent",
+			input:   "blah/blah",
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotErr := validateParent(tt.input)
+			if (tt.wantErr && gotErr == nil) || (!tt.wantErr && gotErr != nil) {
+				t.Errorf("err: got %v, want %v", gotErr, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestLogger_WithRequest(t *testing.T) {
+	now := time.Date(1977, time.May, 25, 0, 0, 0, 0, time.UTC)
+	fnow := now.Format(time.RFC3339)
+
+	t.Run("basic, without trace info", func(t *testing.T) {
+		r, err := http.NewRequest("Get", "http://example.com", nil)
+		if err != nil {
+			t.Fatalf("unable to create request: %v", err)
+		}
+		l, err := NewLogger("projects/test/log123")
+		if err != nil {
+			t.Fatalf("unable to create logger: %v", err)
+		}
+		l = l.WithRequest(r)
+		buf := bytes.NewBuffer(nil)
+		l.w = buf
+		l.now = func() time.Time {
+			return now
+		}
+		e := entry{
+			Message:   "Hello, World!",
+			Severity:  "INFO",
+			Timestamp: fnow,
+			HTTPRequest: &ltype.HttpRequest{
+				RequestMethod: "Get",
+				RequestUrl:    "http://example.com",
+				Protocol:      "HTTP/1.1",
+			},
+		}
+
+		l.Infof("Hello, World!")
+		b, err := json.Marshal(e)
+		if err != nil {
+			t.Fatalf("unable to marshal: %v", err)
+		}
+		if diff := cmp.Diff(string(b), strings.TrimSpace(buf.String())); diff != "" {
+			t.Fatalf("Logger.Warnf() mismatch (-want +got):\n%s", diff)
+		}
+	})
+
+	t.Run("with trace header", func(t *testing.T) {
+		r, err := http.NewRequest("Get", "http://example.com", nil)
+		if err != nil {
+			t.Fatalf("unable to create request: %v", err)
+		}
+		r.Header.Set(internal.TraceHeader, "105445aa7843bc8bf206b120001000/1;o=1")
+		l, err := NewLogger("projects/test")
+		if err != nil {
+			t.Fatalf("unable to create logger: %v", err)
+		}
+		l = l.WithRequest(r)
+		buf := bytes.NewBuffer(nil)
+		l.w = buf
+		l.now = func() time.Time {
+			return now
+		}
+		e := entry{
+			Message:   "Hello, World!",
+			Severity:  "INFO",
+			Timestamp: fnow,
+			HTTPRequest: &ltype.HttpRequest{
+				RequestMethod: "Get",
+				RequestUrl:    "http://example.com",
+				Protocol:      "HTTP/1.1",
+			},
+			Trace:        "projects/test/traces/105445aa7843bc8bf206b120001000",
+			SpanID:       "1",
+			TraceSampled: true,
+		}
+
+		l.Infof("Hello, World!")
+		b, err := json.Marshal(e)
+		if err != nil {
+			t.Fatalf("unable to marshal: %v", err)
+		}
+		if diff := cmp.Diff(string(b), strings.TrimSpace(buf.String())); diff != "" {
+			t.Fatalf("Logger.Warnf() mismatch (-want +got):\n%s", diff)
+		}
+	})
+}
diff --git a/logging/jsonlog/option.go b/logging/jsonlog/option.go
new file mode 100644
index 0000000..7d2c27d
--- /dev/null
+++ b/logging/jsonlog/option.go
@@ -0,0 +1,63 @@
+// Copyright 2021 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.
+
+package jsonlog
+
+import (
+	"io"
+)
+
+// LoggerOption is a configuration option for a Logger.
+type LoggerOption interface {
+	set(*Logger)
+}
+
+// OnErrorHook registers a function that will be called anytime an error occurs
+// during logging.
+func OnErrorHook(hook func(error)) LoggerOption { return onErrorHook{hook: hook} }
+
+type onErrorHook struct{ hook func(error) }
+
+func (h onErrorHook) set(l *Logger) {
+	l.errhook = h.hook
+}
+
+// WithWriter changes where the JSON payloads of a Logger
+// are written to. By default they are written to Stderr.
+func WithWriter(w io.Writer) LoggerOption { return withWriter{w: w} }
+
+type withWriter struct {
+	w io.Writer
+}
+
+func (w withWriter) set(l *Logger) {
+	l.w = w.w
+}
+
+// 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) {
+	labels := map[string]string{}
+	for k, v := range c {
+		labels[k] = v
+	}
+	l.labels = labels
+}
diff --git a/logging/jsonlog/option_test.go b/logging/jsonlog/option_test.go
new file mode 100644
index 0000000..0e4f13e
--- /dev/null
+++ b/logging/jsonlog/option_test.go
@@ -0,0 +1,72 @@
+// Copyright 2021 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.
+
+package jsonlog
+
+import (
+	"bytes"
+	"encoding/json"
+	"testing"
+
+	"cloud.google.com/go/logging"
+)
+
+func TestOnErrorHook(t *testing.T) {
+	var i *int = new(int)
+	fn := func(error) {
+		*i++
+	}
+	l, err := NewLogger("projects/test", OnErrorHook(fn))
+	if err != nil {
+		t.Fatalf("unable to create logger: %v", err)
+	}
+	l.Log(logging.Entry{
+		Payload: false,
+	})
+	if *i != 1 {
+		t.Fatalf("got %d, want %d", *i, 1)
+	}
+}
+
+func TestWithWriter(t *testing.T) {
+	buf := bytes.NewBuffer(nil)
+	l, err := NewLogger("projects/test", WithWriter(buf))
+	if err != nil {
+		t.Fatalf("unable to create logger: %v", err)
+	}
+	if buf.Len() != 0 {
+		t.Fatalf("buf.Len() = %d, want 0", buf.Len())
+	}
+	l.Infof("Test")
+	if buf.Len() == 0 {
+		t.Fatalf("buf.Len() = %d, want >0", buf.Len())
+	}
+}
+
+func TestCommonLabels(t *testing.T) {
+	buf := bytes.NewBuffer(nil)
+	l, err := NewLogger("projects/test", CommonLabels(map[string]string{"foo": "bar"}))
+	if err != nil {
+		t.Fatalf("unable to create logger: %v", err)
+	}
+	l.w = buf
+	l.Infof("Test")
+	e := &entry{}
+	if err := json.Unmarshal(buf.Bytes(), e); err != nil {
+		t.Fatalf("unable to unmarshal: %v", err)
+	}
+	if e.Labels["foo"] != "bar" {
+		t.Fatalf("le.Labels[\"foo\"] = %q, want \"bar\"", e.Labels["foo"])
+	}
+}
diff --git a/logging/logging.go b/logging/logging.go
index 81ede6a..9865bca 100644
--- a/logging/logging.go
+++ b/logging/logging.go
@@ -25,31 +25,28 @@
 package logging
 
 import (
-	"bytes"
 	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"log"
 	"net/http"
-	"regexp"
 	"strconv"
 	"strings"
 	"sync"
 	"time"
-	"unicode/utf8"
 
 	"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"
 	"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"
+	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/types/known/durationpb"
+	"google.golang.org/protobuf/types/known/timestamppb"
 )
 
 const (
@@ -179,16 +176,13 @@
 // 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 {
-	unixZeroTimestamp, err := ptypes.TimestampProto(time.Unix(0, 0))
-	if err != nil {
-		return err
-	}
+	unixZeroTimestamp := timestamppb.New(time.Unix(0, 0))
 	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{
+	_, err := c.client.WriteLogEntries(ctx, &logpb.WriteLogEntriesRequest{
 		LogName:  internal.LogPath(c.parent, "ping"),
 		Resource: monitoredResource(c.parent),
 		Entries:  []*logpb.LogEntry{ent},
@@ -600,7 +594,7 @@
 	u.Fragment = ""
 	pb := &logtypepb.HttpRequest{
 		RequestMethod:                  r.Request.Method,
-		RequestUrl:                     fixUTF8(u.String()),
+		RequestUrl:                     internal.FixUTF8(u.String()),
 		RequestSize:                    r.RequestSize,
 		Status:                         int32(r.Status),
 		ResponseSize:                   r.ResponseSize,
@@ -615,92 +609,11 @@
 		CacheLookup:                    r.CacheLookup,
 	}
 	if r.Latency != 0 {
-		pb.Latency = ptypes.DurationProto(r.Latency)
+		pb.Latency = durationpb.New(r.Latency)
 	}
 	return pb, nil
 }
 
-// fixUTF8 is a helper that fixes an invalid UTF-8 string by replacing
-// invalid UTF-8 runes with the Unicode replacement character (U+FFFD).
-// See Issue https://github.com/googleapis/google-cloud-go/issues/1383.
-func fixUTF8(s string) string {
-	if utf8.ValidString(s) {
-		return s
-	}
-
-	// Otherwise time to build the sequence.
-	buf := new(bytes.Buffer)
-	buf.Grow(len(s))
-	for _, r := range s {
-		if utf8.ValidRune(r) {
-			buf.WriteRune(r)
-		} else {
-			buf.WriteRune('\uFFFD')
-		}
-	}
-	return buf.String()
-}
-
-// 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:
-		return &structpb.Value{Kind: &structpb.Value_NullValue{}}
-	}
-}
-
 // 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.
@@ -767,35 +680,6 @@
 // (for example by calling SetFlags or SetPrefix).
 func (l *Logger) StandardLogger(s Severity) *log.Logger { return l.stdLoggers[s] }
 
-var reCloudTraceContext = regexp.MustCompile(
-	// Matches on "TRACE_ID"
-	`([a-f\d]+)?` +
-		// Matches on "/SPAN_ID"
-		`(?:/([a-f\d]+))?` +
-		// Matches on ";0=TRACE_TRUE"
-		`(?:;o=(\d))?`)
-
-func deconstructXCloudTraceContext(s string) (traceID, spanID string, traceSampled bool) {
-	// As per the format described at https://cloud.google.com/trace/docs/setup#force-trace
-	//    "X-Cloud-Trace-Context: TRACE_ID/SPAN_ID;o=TRACE_TRUE"
-	// for example:
-	//    "X-Cloud-Trace-Context: 105445aa7843bc8bf206b120001000/1;o=1"
-	//
-	// We expect:
-	//   * traceID (optional): 			"105445aa7843bc8bf206b120001000"
-	//   * spanID (optional):       	"1"
-	//   * traceSampled (optional): 	true
-	matches := reCloudTraceContext.FindStringSubmatch(s)
-
-	traceID, spanID, traceSampled = matches[1], matches[2], matches[3] == "1"
-
-	if spanID == "0" {
-		spanID = ""
-	}
-
-	return
-}
-
 // ToLogEntry takes an Entry structure and converts it to the LogEntry proto.
 // A parent can take any of the following forms:
 //    projects/PROJECT_ID
@@ -823,16 +707,13 @@
 	if t.IsZero() {
 		t = now()
 	}
-	ts, err := ptypes.TimestampProto(t)
-	if err != nil {
-		return nil, err
-	}
+	ts := timestamppb.New(t)
 	if e.Trace == "" && e.HTTPRequest != nil && e.HTTPRequest.Request != nil {
-		traceHeader := e.HTTPRequest.Request.Header.Get("X-Cloud-Trace-Context")
+		traceHeader := e.HTTPRequest.Request.Header.Get(internal.TraceHeader)
 		if traceHeader != "" {
 			// Set to a relative resource name, as described at
 			// https://cloud.google.com/appengine/docs/flexible/go/writing-application-logs.
-			traceID, spanID, traceSampled := deconstructXCloudTraceContext(traceHeader)
+			traceID, spanID, traceSampled := internal.DeconstructXCloudTraceContext(traceHeader)
 			if traceID != "" {
 				e.Trace = fmt.Sprintf("%s/traces/%s", parent, traceID)
 			}
@@ -871,7 +752,7 @@
 	case string:
 		ent.Payload = &logpb.LogEntry_TextPayload{TextPayload: p}
 	default:
-		s, err := toProtoStruct(p)
+		s, err := internal.ToProtoStruct(p)
 		if err != nil {
 			return nil, err
 		}
diff --git a/logging/logging_test.go b/logging/logging_test.go
index 495303e..a79b0c0 100644
--- a/logging/logging_test.go
+++ b/logging/logging_test.go
@@ -37,6 +37,7 @@
 	"cloud.google.com/go/internal/testutil"
 	"cloud.google.com/go/internal/uid"
 	"cloud.google.com/go/logging"
+	"cloud.google.com/go/logging/internal"
 	ltesting "cloud.google.com/go/logging/internal/testing"
 	"cloud.google.com/go/logging/logadmin"
 	gax "github.com/googleapis/gax-go/v2"
@@ -282,7 +283,7 @@
 				HTTPRequest: &logging.HTTPRequest{
 					Request: &http.Request{
 						URL:    u,
-						Header: http.Header{"X-Cloud-Trace-Context": {"105445aa7843bc8bf206b120001000/000000000000004a;o=1"}},
+						Header: http.Header{internal.TraceHeader: {"105445aa7843bc8bf206b120001000/000000000000004a;o=1"}},
 					},
 				},
 			},
@@ -298,7 +299,7 @@
 				HTTPRequest: &logging.HTTPRequest{
 					Request: &http.Request{
 						URL:    u,
-						Header: http.Header{"X-Cloud-Trace-Context": {"105445aa7843bc8bf206b120001000/000000000000004a;o=0"}},
+						Header: http.Header{internal.TraceHeader: {"105445aa7843bc8bf206b120001000/000000000000004a;o=0"}},
 					},
 				},
 			},
@@ -313,7 +314,7 @@
 				HTTPRequest: &logging.HTTPRequest{
 					Request: &http.Request{
 						URL:    u,
-						Header: http.Header{"X-Cloud-Trace-Context": {"105445aa7843bc8bf206b120001000/000000000000004a;o=1"}},
+						Header: http.Header{internal.TraceHeader: {"105445aa7843bc8bf206b120001000/000000000000004a;o=1"}},
 					},
 				},
 			},
@@ -328,7 +329,7 @@
 				HTTPRequest: &logging.HTTPRequest{
 					Request: &http.Request{
 						URL:    u,
-						Header: http.Header{"X-Cloud-Trace-Context": {"/0;o=1"}},
+						Header: http.Header{internal.TraceHeader: {"/0;o=1"}},
 					},
 				},
 			},
@@ -341,7 +342,7 @@
 				HTTPRequest: &logging.HTTPRequest{
 					Request: &http.Request{
 						URL:    u,
-						Header: http.Header{"X-Cloud-Trace-Context": {"105445aa7843bc8bf206b120001000/;o=0"}},
+						Header: http.Header{internal.TraceHeader: {"105445aa7843bc8bf206b120001000/;o=0"}},
 					},
 				},
 			},
@@ -354,7 +355,7 @@
 				HTTPRequest: &logging.HTTPRequest{
 					Request: &http.Request{
 						URL:    u,
-						Header: http.Header{"X-Cloud-Trace-Context": {"105445aa7843bc8bf206b120001000/0"}},
+						Header: http.Header{internal.TraceHeader: {"105445aa7843bc8bf206b120001000/0"}},
 					},
 				},
 			},
@@ -367,7 +368,7 @@
 				HTTPRequest: &logging.HTTPRequest{
 					Request: &http.Request{
 						URL:    u,
-						Header: http.Header{"X-Cloud-Trace-Context": {""}},
+						Header: http.Header{internal.TraceHeader: {""}},
 					},
 				},
 			},
@@ -378,7 +379,7 @@
 				HTTPRequest: &logging.HTTPRequest{
 					Request: &http.Request{
 						URL:    u,
-						Header: http.Header{"X-Cloud-Trace-Context": {"t3"}},
+						Header: http.Header{internal.TraceHeader: {"t3"}},
 					},
 				},
 				Trace: "t4",
diff --git a/logging/logging_unexported_test.go b/logging/logging_unexported_test.go
index 6d1ac9c..f7b32b6 100644
--- a/logging/logging_unexported_test.go
+++ b/logging/logging_unexported_test.go
@@ -24,12 +24,12 @@
 	"time"
 
 	"cloud.google.com/go/internal/testutil"
-	"github.com/golang/protobuf/proto"
 	durpb "github.com/golang/protobuf/ptypes/duration"
 	structpb "github.com/golang/protobuf/ptypes/struct"
 	"google.golang.org/api/support/bundler"
 	mrpb "google.golang.org/genproto/googleapis/api/monitoredres"
 	logtypepb "google.golang.org/genproto/googleapis/logging/type"
+	"google.golang.org/protobuf/proto"
 )
 
 func TestLoggerCreation(t *testing.T) {
@@ -120,65 +120,6 @@
 	}
 }
 
-func TestToProtoStruct(t *testing.T) {
-	v := struct {
-		Foo string                 `json:"foo"`
-		Bar int                    `json:"bar,omitempty"`
-		Baz []float64              `json:"baz"`
-		Moo map[string]interface{} `json:"moo"`
-	}{
-		Foo: "foovalue",
-		Baz: []float64{1.1},
-		Moo: map[string]interface{}{
-			"a": 1,
-			"b": "two",
-			"c": true,
-		},
-	}
-
-	got, err := toProtoStruct(v)
-	if err != nil {
-		t.Fatal(err)
-	}
-	want := &structpb.Struct{
-		Fields: map[string]*structpb.Value{
-			"foo": {Kind: &structpb.Value_StringValue{StringValue: v.Foo}},
-			"baz": {Kind: &structpb.Value_ListValue{ListValue: &structpb.ListValue{Values: []*structpb.Value{
-				{Kind: &structpb.Value_NumberValue{NumberValue: 1.1}},
-			}}}},
-			"moo": {Kind: &structpb.Value_StructValue{
-				StructValue: &structpb.Struct{
-					Fields: map[string]*structpb.Value{
-						"a": {Kind: &structpb.Value_NumberValue{NumberValue: 1}},
-						"b": {Kind: &structpb.Value_StringValue{StringValue: "two"}},
-						"c": {Kind: &structpb.Value_BoolValue{BoolValue: true}},
-					},
-				},
-			}},
-		},
-	}
-	if !proto.Equal(got, want) {
-		t.Errorf("got  %+v\nwant %+v", got, want)
-	}
-
-	// Non-structs should fail to convert.
-	for v := range []interface{}{3, "foo", []int{1, 2, 3}} {
-		_, err := toProtoStruct(v)
-		if err == nil {
-			t.Errorf("%v: got nil, want error", v)
-		}
-	}
-
-	// Test fast path.
-	got, err = toProtoStruct(want)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if got != want {
-		t.Error("got and want should be identical, but are not")
-	}
-}
-
 func TestToLogEntryPayload(t *testing.T) {
 	for _, test := range []struct {
 		in         interface{}