change logging code to avoid panics

It makes no sense to risk panicking from within logging routine
just because the caller botched their x.Marshall() method. This
might impact the production app, if they don't exhaustively test
marshaling. Correctness of logging is not worth THAT much.

Also, move testing code to _test.go. This means it won't be compiled
for live code.

glog.go

@@ -679,7 +679,9 @@ func logj(s severity, l *Logger, msg string, j interface{}) {
 	// }
 	buf, err := json.Marshal(j)
 	if err != nil {
-		panic(err)
+		// Ignore. This is just logging. Do not panic the entire app
+		// just because the caller had botched their x.Marshal(), etc.
+		return
 	}
 
 	logRawJSON(s, l, msg, buf)
@@ -700,22 +702,22 @@ func logRawJSON(s severity, l *Logger, msg string, buf []byte) {
 	if msg != "" {
 		msgj, err = json.Marshal(msg)
 		if err != nil {
-			panic(err)
+			return
 		}
 	}
 
 	sev := s.String()
 	if sev != "" {
 		sevj, err = json.Marshal(sev)
 		if err != nil {
-			panic(err)
+			return
 		}
 	}
 
 	if l.trace != "" {
 		tracej, err = json.Marshal(l.trace)
 		if err != nil {
-			panic(err)
+			return
 		}
 	}
 
@@ -804,28 +806,3 @@ func logRawJSON(s severity, l *Logger, msg string, buf []byte) {
 	}
 }
 
-// logjStdlib is only here to benchmark the stdlib "encoding/json"
-// approach.
-func logjStdlib(s severity, l *Logger, msg string, j interface{}) {
-	entry := make(map[string]json.RawMessage)
-
-	if buf, err := json.Marshal(j); err != nil {
-		panic(err)
-	} else if err := json.Unmarshal(buf, &entry); err != nil {
-		panic(err)
-	}
-
-	if v := msg; v != "" {
-		entry["message"], _ = json.Marshal(v)
-	}
-	if v := s.String(); v != "" {
-		entry["severity"], _ = json.Marshal(v)
-	}
-	if v := l.trace; v != "" {
-		entry["logging.googleapis.com/trace"], _ = json.Marshal(v)
-	}
-
-	l.mu.Lock()
-	defer l.mu.Unlock()
-	_ = json.NewEncoder(l.writer(s)).Encode(entry)
-}

glog_test.go

@@ -405,3 +405,29 @@ func BenchmarkStdlibTen(b *testing.B) {
 		buf.Reset()
 	}
 }
+
+// logjStdlib is only here to benchmark the stdlib "encoding/json"
+// approach. Hopefully our method is much faster than stdlib.
+func logjStdlib(s severity, l *Logger, msg string, j interface{}) {
+	entry := make(map[string]json.RawMessage)
+
+	if buf, err := json.Marshal(j); err != nil {
+		panic(err)
+	} else if err := json.Unmarshal(buf, &entry); err != nil {
+		panic(err)
+	}
+
+	if v := msg; v != "" {
+		entry["message"], _ = json.Marshal(v)
+	}
+	if v := s.String(); v != "" {
+		entry["severity"], _ = json.Marshal(v)
+	}
+	if v := l.trace; v != "" {
+		entry["logging.googleapis.com/trace"], _ = json.Marshal(v)
+	}
+
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	_ = json.NewEncoder(l.writer(s)).Encode(entry)
+}