diff --git a/core/pkg/logtree/BUILD.bazel b/core/pkg/logtree/BUILD.bazel
index 7b899a4..1498e07 100644
--- a/core/pkg/logtree/BUILD.bazel
+++ b/core/pkg/logtree/BUILD.bazel
@@ -26,7 +26,6 @@
     srcs = [
         "journal_test.go",
         "logtree_test.go",
-        "payload_test.go",
     ],
     embed = [":go_default_library"],
 )
diff --git a/core/pkg/logtree/doc.go b/core/pkg/logtree/doc.go
index caef97a..ab3c537 100644
--- a/core/pkg/logtree/doc.go
+++ b/core/pkg/logtree/doc.go
@@ -16,10 +16,11 @@
 
 /*
 Package logtree implements a tree-shaped logger for debug events. It provides log publishers (ie. Go code) with a
-glog-like API, with loggers placed in a hierarchical structure defined by a dot-delimited path (called a DN, short for
-Distinguished Name).
+glog-like API and io.Writer API, with loggers placed in a hierarchical structure defined by a dot-delimited path
+(called a DN, short for Distinguished Name).
 
     tree.MustLeveledFor("foo.bar.baz").Warningf("Houston, we have a problem: %v", err)
+    fmt.Fprintf(tree.MustRawFor("foo.bar.baz"), "some\nunstructured\ndata\n")
 
 Logs in this context are unstructured, operational and developer-centric human readable text messages presented as lines
 of text to consumers, with some attached metadata. Logtree does not deal with 'structured' logs as some parts of the
@@ -69,7 +70,7 @@
 logs of the entire tree, just a single DN (like svc), or a subtree (like everything under listener, ie. messages emitted
 to listener.http and listener.grpc).
 
-Log Producer API
+Leveled Log Producer API
 
 As part of the glog-like logging API available to producers, the following metadata is attached to emitted logs in
 addition to the DN of the logger to which the log entry was emitted:
@@ -82,6 +83,18 @@
 node of the tree. For more information about the producer-facing logging API, see the documentation of the LeveledLogger
 interface, which is the main interface exposed to log producers.
 
+If the submitted message contains newlines, it will be split accordingly into a single log entry that contains multiple
+string lines. This allows for log producers to submit long, multi-line messages that are guaranteed to be non-interleaved
+with other entries, and allows for access API consumers to maintain semantic linking between multiple lines being emitted
+as a single atomic entry.
+
+Raw Log Producer API
+
+In addition to leveled, glog-like logging, LogTree supports 'raw logging'. This is implemented as an io.Writer that will
+split incoming bytes into newline-delimited lines, and log them into that logtree's DN. This mechanism is primarily
+intended to support storage of unstructured log data from external processes - for example binaries running with redirected
+stdout/stderr.
+
 Log Access API
 
 The Log Access API is mostly exposed via a single function on the LogTree struct: Read. It allows access to log entries
@@ -94,5 +107,10 @@
 Thus, log consumers should be aware that it is much better to stream and buffer logs specific to some long-standing
 logging request on their own, rather than repeatedly perform reads of a subtree backlog.
 
+The data returned from the log access API is a LogEntry, which itself can contain either a raw logging entry, or a leveled
+logging entry. Helper functions are available on LogEntry that allow canonical string representations to be returned, for
+easy use in consuming tools/interfaces. Alternatively, the consumer can itself access the internal raw/leveled entries and
+print them according to their own preferred format.
+
 */
 package logtree
diff --git a/core/pkg/logtree/journal_test.go b/core/pkg/logtree/journal_test.go
index 253fc8d..474748a 100644
--- a/core/pkg/logtree/journal_test.go
+++ b/core/pkg/logtree/journal_test.go
@@ -18,9 +18,21 @@
 
 import (
 	"fmt"
+	"strings"
 	"testing"
+	"time"
 )
 
+func testPayload(msg string) *LeveledPayload {
+	return &LeveledPayload{
+		messages:  []string{msg},
+		timestamp: time.Now(),
+		severity:  INFO,
+		file:      "main.go",
+		line:      1337,
+	}
+}
+
 func TestJournalRetention(t *testing.T) {
 	j := newJournal()
 
@@ -38,7 +50,7 @@
 	}
 	for i, entry := range entries {
 		want := fmt.Sprintf("test %d", (9000-8192)+i)
-		got := entry.leveled.message
+		got := strings.Join(entry.leveled.messages, "\n")
 		if want != got {
 			t.Fatalf("wanted entry %q, got %q", want, got)
 		}
@@ -80,7 +92,7 @@
 	}
 	setMessages := make(map[string]bool)
 	for _, entry := range entries {
-		setMessages[entry.leveled.message] = true
+		setMessages[strings.Join(entry.leveled.messages, "\n")] = true
 	}
 
 	for i := 0; i < 900; i += 1 {
@@ -110,7 +122,7 @@
 		res := j.scanEntries(f)
 		set := make(map[string]bool)
 		for _, entry := range res {
-			set[entry.leveled.message] = true
+			set[strings.Join(entry.leveled.messages, "\n")] = true
 		}
 
 		for _, want := range msgs {
diff --git a/core/pkg/logtree/logtree_access.go b/core/pkg/logtree/logtree_access.go
index bb8a524..7709526 100644
--- a/core/pkg/logtree/logtree_access.go
+++ b/core/pkg/logtree/logtree_access.go
@@ -19,6 +19,7 @@
 import (
 	"errors"
 	"fmt"
+	"strings"
 	"sync/atomic"
 
 	"git.monogon.dev/source/nexantic.git/core/pkg/logbuffer"
@@ -102,6 +103,59 @@
 	DN DN
 }
 
+// String returns a canonical representation of this payload as a single string prefixed with metadata. If the entry is
+// a leveled log entry that originally was logged with newlines this representation will also contain newlines, with
+// each original message part prefixed by the metadata.
+// For an alternative call that will instead return a canonical prefix and a list of lines in the message, see Strings().
+func (l *LogEntry) String() string {
+	if l.Leveled != nil {
+		prefix, messages := l.Leveled.Strings()
+		res := make([]string, len(messages))
+		for i, m := range messages {
+			res[i] = fmt.Sprintf("%-32s %s%s", l.DN, prefix, m)
+		}
+		return strings.Join(res, "\n")
+	}
+	if l.Raw != nil {
+		return fmt.Sprintf("%-32s R %s", l.DN, l.Raw)
+	}
+	return "INVALID"
+}
+
+// Strings returns the canonical representation of this payload split into a prefix and all lines that were contained in
+// the original message. This is meant to be displayed to the user by showing the prefix before each line, concatenated
+// together - possibly in a table form with the prefixes all unified with a rowspan-like mechanism.
+//
+// For example, this function can return:
+//   prefix = "root.foo.bar                    I1102 17:20:06.921395     0 foo.go:42] "
+//   lines = []string{"current tags:", " - one", " - two"}
+//
+// With this data, the result should be presented to users this way in text form:
+// root.foo.bar                    I1102 17:20:06.921395 foo.go:42] current tags:
+// root.foo.bar                    I1102 17:20:06.921395 foo.go:42]  - one
+// root.foo.bar                    I1102 17:20:06.921395 foo.go:42]  - two
+//
+// Or, in a table layout:
+// .-------------------------------------------------------------------------------------.
+// | root.foo.bar                    I1102 17:20:06.921395 foo.go:42] : current tags:    |
+// |                                                                  :------------------|
+// |                                                                  :  - one           |
+// |                                                                  :------------------|
+// |                                                                  :  - two           |
+// '-------------------------------------------------------------------------------------'
+//
+func (l *LogEntry) Strings() (prefix string, lines []string) {
+	if l.Leveled != nil {
+		prefix, messages := l.Leveled.Strings()
+		prefix = fmt.Sprintf("%-32s %s", l.DN, prefix)
+		return prefix, messages
+	}
+	if l.Raw != nil {
+		return fmt.Sprintf("%-32s R ", l.DN), []string{l.Raw.Data}
+	}
+	return "INVALID ", []string{"INVALID"}
+}
+
 // Convert this LogEntry to proto. Returned value may be nil if given LogEntry is invalid, eg. contains neither a Raw
 // nor Leveled entry.
 func (l *LogEntry) Proto() *apb.LogEntry {
@@ -125,23 +179,6 @@
 	return p
 }
 
-// String returns a standardized human-readable representation of either underlying raw or leveled entry. The returned
-// data is pre-formatted to be displayed in a fixed-width font.
-func (l *LogEntry) String() string {
-	if l.Leveled != nil {
-		// Use glog-like layout, but with supervisor DN instead of filename.
-		timestamp := l.Leveled.Timestamp()
-		_, month, day := timestamp.Date()
-		hour, minute, second := timestamp.Clock()
-		nsec := timestamp.Nanosecond() / 1000
-		return fmt.Sprintf("%s%02d%02d %02d:%02d:%02d.%06d %s] %s", l.Leveled.Severity(), month, day, hour, minute, second, nsec, l.DN, l.Leveled.Message())
-	}
-	if l.Raw != nil {
-		return fmt.Sprintf("%-32s R %s", l.DN, l.Raw)
-	}
-	return "INVALID"
-}
-
 // Parse a proto LogEntry back into internal structure. This can be used in log proto API consumers to easily print
 // received log entries.
 func LogEntryFromProto(l *apb.LogEntry) (*LogEntry, error) {
diff --git a/core/pkg/logtree/logtree_publisher.go b/core/pkg/logtree/logtree_publisher.go
index c898012..190ef7e 100644
--- a/core/pkg/logtree/logtree_publisher.go
+++ b/core/pkg/logtree/logtree_publisher.go
@@ -92,10 +92,13 @@
 		}
 	}
 
+	// Remove leading/trailing newlines and split.
+	messages := strings.Split(strings.Trim(msg, "\n"), "\n")
+
 	p := &LeveledPayload{
 		timestamp: time.Now(),
 		severity:  severity,
-		message:   msg,
+		messages:  messages,
 		file:      file,
 		line:      line,
 	}
diff --git a/core/pkg/logtree/logtree_test.go b/core/pkg/logtree/logtree_test.go
index f1465ad..b900201 100644
--- a/core/pkg/logtree/logtree_test.go
+++ b/core/pkg/logtree/logtree_test.go
@@ -18,12 +18,49 @@
 
 import (
 	"fmt"
-	"log"
 	"strings"
 	"testing"
 	"time"
 )
 
+func expect(tree *LogTree, t *testing.T, dn DN, entries ...string) string {
+	t.Helper()
+	res, err := tree.Read(dn, WithChildren(), WithBacklog(BacklogAllAvailable))
+	if err != nil {
+		t.Fatalf("Read: %v", err)
+	}
+	if want, got := len(entries), len(res.Backlog); want != got {
+		t.Fatalf("wanted %v backlog entries, got %v", want, got)
+	}
+	got := make(map[string]bool)
+	for _, entry := range res.Backlog {
+		if entry.Leveled != nil {
+			got[entry.Leveled.MessagesJoined()] = true
+		}
+		if entry.Raw != nil {
+			got[entry.Raw.Data] = true
+		}
+	}
+	for _, entry := range entries {
+		if !got[entry] {
+			return fmt.Sprintf("missing entry %q", entry)
+		}
+	}
+	return ""
+}
+
+func TestMultiline(t *testing.T) {
+	tree := New()
+	// Two lines in a single message.
+	tree.MustLeveledFor("main").Info("foo\nbar")
+	// Two lines in a single message with a hanging newline that should get stripped.
+	tree.MustLeveledFor("main").Info("one\ntwo\n")
+
+	if res := expect(tree, t, "main", "foo\nbar", "one\ntwo"); res != "" {
+		t.Errorf("retrieval at main failed: %s", res)
+	}
+}
+
 func TestBacklog(t *testing.T) {
 	tree := New()
 	tree.MustLeveledFor("main").Info("hello, main!")
@@ -33,38 +70,13 @@
 	// No newline at the last entry - shouldn't get propagated to the backlog.
 	fmt.Fprintf(tree.MustRawFor("aux.process"), "processing foo\nprocessing bar\nbaz")
 
-	expect := func(dn DN, entries ...string) string {
-		res, err := tree.Read(dn, WithChildren(), WithBacklog(BacklogAllAvailable))
-		if err != nil {
-			t.Fatalf("Read: %v", err)
-		}
-		if want, got := len(entries), len(res.Backlog); want != got {
-			t.Fatalf("wanted %d backlog entries, got %d", want, got)
-		}
-		got := make(map[string]bool)
-		for _, entry := range res.Backlog {
-			if entry.Leveled != nil {
-				got[entry.Leveled.Message()] = true
-			}
-			if entry.Raw != nil {
-				got[entry.Raw.Data] = true
-			}
-		}
-		for _, entry := range entries {
-			if !got[entry] {
-				return fmt.Sprintf("missing entry %q", entry)
-			}
-		}
-		return ""
-	}
-
-	if res := expect("main", "hello, main!", "hello, main.foo!", "hello, main.bar!"); res != "" {
+	if res := expect(tree, t, "main", "hello, main!", "hello, main.foo!", "hello, main.bar!"); res != "" {
 		t.Errorf("retrieval at main failed: %s", res)
 	}
-	if res := expect("", "hello, main!", "hello, main.foo!", "hello, main.bar!", "hello, aux!", "processing foo", "processing bar"); res != "" {
+	if res := expect(tree, t, "", "hello, main!", "hello, main.foo!", "hello, main.bar!", "hello, aux!", "processing foo", "processing bar"); res != "" {
 		t.Errorf("retrieval at root failed: %s", res)
 	}
-	if res := expect("aux", "hello, aux!", "processing foo", "processing bar"); res != "" {
+	if res := expect(tree, t, "aux", "hello, aux!", "processing foo", "processing bar"); res != "" {
 		t.Errorf("retrieval at aux failed: %s", res)
 	}
 }
@@ -74,12 +86,10 @@
 	tree.MustLeveledFor("main").Info("hello, backlog")
 	fmt.Fprintf(tree.MustRawFor("main.process"), "hello, raw backlog\n")
 
-	log.Printf("read start")
 	res, err := tree.Read("", WithBacklog(BacklogAllAvailable), WithChildren(), WithStream())
 	if err != nil {
 		t.Fatalf("Read: %v", err)
 	}
-	log.Printf("read done")
 	defer res.Close()
 	if want, got := 2, len(res.Backlog); want != got {
 		t.Errorf("wanted %d backlog item, got %d", want, got)
@@ -97,7 +107,7 @@
 			done = true
 		case p := <-res.Stream:
 			if p.Leveled != nil {
-				entries[p.Leveled.Message()] = true
+				entries[p.Leveled.MessagesJoined()] = true
 			}
 			if p.Raw != nil {
 				entries[p.Raw.Data] = true
@@ -169,7 +179,7 @@
 		if want, got := te.severity, p.Leveled.Severity(); want != got {
 			t.Errorf("wanted element %d to have severity %s, got %s", te.ix, want, got)
 		}
-		if want, got := te.message, p.Leveled.Message(); want != got {
+		if want, got := te.message, p.Leveled.MessagesJoined(); want != got {
 			t.Errorf("wanted element %d to have message %q, got %q", te.ix, want, got)
 		}
 		if want, got := "logtree_test.go", strings.Split(p.Leveled.Location(), ":")[0]; want != got {
@@ -192,10 +202,10 @@
 	if want, got := 2, len(reader.Backlog); want != got {
 		t.Fatalf("wanted %d entries, got %d", want, got)
 	}
-	if want, got := "i am an error", reader.Backlog[0].Leveled.Message(); want != got {
+	if want, got := "i am an error", reader.Backlog[0].Leveled.MessagesJoined(); want != got {
 		t.Fatalf("wanted entry %q, got %q", want, got)
 	}
-	if want, got := "i am a warning", reader.Backlog[1].Leveled.Message(); want != got {
+	if want, got := "i am a warning", reader.Backlog[1].Leveled.MessagesJoined(); want != got {
 		t.Fatalf("wanted entry %q, got %q", want, got)
 	}
 }
diff --git a/core/pkg/logtree/payload.go b/core/pkg/logtree/payload.go
index ca7a0a0..6338118 100644
--- a/core/pkg/logtree/payload.go
+++ b/core/pkg/logtree/payload.go
@@ -25,11 +25,13 @@
 	apb "git.monogon.dev/source/nexantic.git/core/proto/api"
 )
 
-// LeveledPayload is a log entry for leveled logs (as per leveled.go). It contains not only the log message itself and
-// its severity, but also additional metadata that would be usually seen in a text representation of a leveled log entry.
+// LeveledPayload is a log entry for leveled logs (as per leveled.go). It contains the input to these calls (severity and
+// message split into newline-delimited messages) and additional metadata that would be usually seen in a text
+// representation of a leveled log entry.
 type LeveledPayload struct {
-	// message is the log message, rendered from a leveled log call like Infof(), Warningf(), ...
-	message string
+	// messages is the list of messages contained in this payload. This list is built from splitting up the given message
+	// from the user by newline.
+	messages []string
 	// timestamp is the time at which this message was emitted.
 	timestamp time.Time
 	// severity is the leveled Severity at which this message was emitted.
@@ -40,22 +42,60 @@
 	line int
 }
 
+// String returns a canonical representation of this payload as a single string prefixed with metadata. If the original
+// message was logged with newlines, this representation will also contain newlines, with each original message part
+// prefixed by the metadata.
+// For an alternative call that will instead return a canonical prefix and a list of lines in the message, see Strings().
 func (p *LeveledPayload) String() string {
-	// Same format as in glog:
-	// Lmmdd hh:mm:ss.uuuuuu threadid file:line]
-	// Except, threadid is (currently) always zero. In the future this field might be used for something different.
+	prefix, lines := p.Strings()
+	res := make([]string, len(p.messages))
+	for i, line := range lines {
+		res[i] = fmt.Sprintf("%s%s", prefix, line)
+	}
+	return strings.Join(res, "\n")
+}
 
+// Strings returns the canonical representation of this payload split into a prefix and all lines that were contained in
+// the original message. This is meant to be displayed to the user by showing the prefix before each line, concatenated
+// together - possibly in a table form with the prefixes all unified with a rowspan-like mechanism.
+//
+// For example, this function can return:
+//   prefix = "I1102 17:20:06.921395 foo.go:42] "
+//   lines = []string{"current tags:", " - one", " - two"}
+//
+// With this data, the result should be presented to users this way in text form:
+// I1102 17:20:06.921395 foo.go:42] current tags:
+// I1102 17:20:06.921395 foo.go:42]  - one
+// I1102 17:20:06.921395 foo.go:42]  - two
+//
+// Or, in a table layout:
+// .-----------------------------------------------------------.
+// | I1102 17:20:06.921395     0 foo.go:42] : current tags:    |
+// |                                        :------------------|
+// |                                        :  - one           |
+// |                                        :------------------|
+// |                                        :  - two           |
+// '-----------------------------------------------------------'
+//
+func (p *LeveledPayload) Strings() (prefix string, lines []string) {
 	_, month, day := p.timestamp.Date()
 	hour, minute, second := p.timestamp.Clock()
 	nsec := p.timestamp.Nanosecond() / 1000
 
+	// Same format as in glog, but without treadid.
+	// Lmmdd hh:mm:ss.uuuuuu file:line]
 	// TODO(q3k): rewrite this to printf-less code.
-	return fmt.Sprintf("%s%02d%02d %02d:%02d:%02d.%06d % 7d %s:%d] %s", p.severity, month, day, hour, minute, second,
-		nsec, 0, p.file, p.line, p.message)
+	prefix = fmt.Sprintf("%s%02d%02d %02d:%02d:%02d.%06d %s:%d] ", p.severity, month, day, hour, minute, second, nsec, p.file, p.line)
+
+	lines = p.messages
+	return
 }
 
-// Message returns the inner message of this entry, ie. what was passed to the actual logging method.
-func (p *LeveledPayload) Message() string { return p.message }
+// Message returns the inner message lines of this entry, ie. what was passed to the actual logging method, but split by
+// newlines.
+func (p *LeveledPayload) Messages() []string { return p.messages }
+
+func (p *LeveledPayload) MessagesJoined() string { return strings.Join(p.messages, "\n") }
 
 // Timestamp returns the time at which this entry was logged.
 func (p *LeveledPayload) Timestamp() time.Time { return p.timestamp }
@@ -70,7 +110,7 @@
 // Proto converts a LeveledPayload to protobuf format.
 func (p *LeveledPayload) Proto() *apb.LogEntry_Leveled {
 	return &apb.LogEntry_Leveled{
-		Message:   p.Message(),
+		Lines:     p.Messages(),
 		Timestamp: p.Timestamp().UnixNano(),
 		Severity:  p.Severity().ToProto(),
 		Location:  p.Location(),
@@ -93,7 +133,7 @@
 		return nil, fmt.Errorf("invalid location line number: %w", err)
 	}
 	return &LeveledPayload{
-		message:   p.Message,
+		messages:  p.Lines,
 		timestamp: time.Unix(0, p.Timestamp),
 		severity:  severity,
 		file:      file,
diff --git a/core/pkg/logtree/payload_test.go b/core/pkg/logtree/payload_test.go
deleted file mode 100644
index 789fbcf..0000000
--- a/core/pkg/logtree/payload_test.go
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2020 The Monogon Project Authors.
-//
-// SPDX-License-Identifier: Apache-2.0
-//
-// 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 logtree
-
-import "time"
-
-func testPayload(msg string) *LeveledPayload {
-	return &LeveledPayload{
-		message:   msg,
-		timestamp: time.Now(),
-		severity:  INFO,
-		file:      "main.go",
-		line:      1337,
-	}
-}
diff --git a/core/proto/api/debug.proto b/core/proto/api/debug.proto
index b0bbb57..7a046ec 100644
--- a/core/proto/api/debug.proto
+++ b/core/proto/api/debug.proto
@@ -136,7 +136,7 @@
 
 message LogEntry {
     message Leveled {
-        string message = 1;
+        repeated string lines = 1;
         int64 timestamp = 2;
         LeveledLogSeverity severity = 3;
         string location = 4;