log: experimental android logcat integ

Author: ignoramous

intra/common.go

@@ -557,7 +557,6 @@ func makeIPPorts(ips []netip.Addr, origipp netip.AddrPort, maybeIncludeOrig bool
 		log.VV("com: makeIPPorts(v4? %t, v6? %t) for %v; tot: %d; in: %v, out: %v",
 			use4, use6, origipp, len(ips), ips, r)
 	}
-
 	if len(r) > 0 {
 		s := core.ShuffleInPlace(r)
 		if willIncludeOrig {

intra/log/logger.go

@@ -81,6 +81,7 @@ type simpleLogger struct {
 
 	o *golog.Logger
 	e *golog.Logger
+	x *xlog         // may be used instead of golog o/e
 	q *ring[string] // todo: use []byte instead of string for gc?
 
 	clock
@@ -255,12 +256,16 @@ func defaultLogger() *simpleLogger {
 		// github.com/golang/mobile/blob/fa72addaaa/internal/mobileinit/mobileinit_android.go#L74-L92
 		e: golog.New(os.Stderr, "", defaultFlags),
 		o: golog.New(os.Stdout, "", defaultFlags),
+		x: &xlog{}, // pipes output to logcat on Android, to fmt.Print otherwise
 		q: newRing[string](context.TODO(), qSize),
 	}
+	if runtime.GOOS == "android" {
+		golog.SetOutput(l.x)
+	}
 	return l
 }
 
-// NewLogger creates a new Glogger with the given tag.
+// NewLogger creates a new Logger with the given tag.
 func NewLogger(tag string) *simpleLogger {
 	l := defaultLogger()
 	if len(tag) <= 0 { // if tag is empty, leave it as is
@@ -559,15 +564,23 @@ func (l *simpleLogger) msgstr(lvl LogLevel, f string, args ...any) (msg string)
 // out logs to stdout and pushes msg into ring buffer.
 // ref: github.com/golang/mobile/blob/c713f31d/internal/mobileinit/mobileinit_android.go#L51
 func (l *simpleLogger) out(msg string) {
-	_ = l.o.Output(0 /*not used*/, msg) // may error
+	if runtime.GOOS == "android" {
+		l.x.Write([]byte(msg))
+	} else {
+		_ = l.o.Output(0 /*not used*/, msg) // may error
+	}
 	l.q.Push(msg)
 }
 
 // err logs to stderr and pushes msg into ring buffer.
 func (l *simpleLogger) err(at int, msg string) {
 	_, file := caller(at + nextframe)
 	msg = file + msg
-	_ = l.e.Output(0 /*unused*/, msg) // may error
+	if runtime.GOOS == "android" {
+		l.x.Write([]byte(msg))
+	} else {
+		_ = l.e.Output(0 /*unused*/, msg) // may error
+	}
 	l.q.Push(msg)
 }
 
@@ -644,6 +657,35 @@ func tracecaller(s string) bool {
 	return true
 }
 
+// splitmsg parses the two-character level prefix prepended by msgstr
+// ("D ", "I ", "W ", "E ") and returns the corresponding LogLevel
+// together with the message with that prefix stripped.
+// If the prefix is not recognised, INFO and the original slice are returned.
+func splitmsg(p []byte) (LogLevel, Logmsg) {
+	if len(p) >= 2 && p[1] == ' ' {
+		switch p[0] {
+		case 'Y':
+			return VVERBOSE, Logmsg(p[2:])
+		case 'V':
+			return VERBOSE, Logmsg(p[2:])
+		case 'D':
+			return DEBUG, Logmsg(p[2:])
+		case 'I':
+			return INFO, Logmsg(p[2:])
+		case 'W':
+			return WARN, Logmsg(p[2:])
+		case 'E':
+			return ERROR, Logmsg(p[2:])
+		case 'F':
+			return STACKTRACE, Logmsg(p[2:])
+		case 'U':
+			return USR, Logmsg(p[2:])
+		}
+	}
+	return INFO, Logmsg(p)
+}
+
+// shortfile strips the last path component from a file path.
 func shortfile(file string) string {
 	if i := strings.LastIndexByte(file, '/'); i >= 0 {
 		file = file[i+1:]

intra/log/xlog_android.go

@@ -0,0 +1,91 @@
+// Copyright (c) 2026 RethinkDNS and its authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+//
+// This file incorporates work covered by the following copyright and
+// permission notice:
+//
+//    Copyright 2014 The Go Authors. All rights reserved.
+//    Use of this source code is governed by a BSD-style
+//    license that can be found in the LICENSE file.
+
+//go:build android && cgo
+
+package log
+
+// adb logcat Firestack:D Firestack:I Firestack:W Firestack:E *:S
+
+/*
+#cgo LDFLAGS: -landroid -llog
+
+#include <stdarg.h>
+#include <stdlib.h>
+#include <android/log.h>
+*/
+import "C"
+
+import (
+	"io"
+	"strings"
+	"unsafe"
+)
+
+// ctag is the logcat tag used for all log output.
+var ctag = C.CString("Firestack")
+
+// xlog is a Console implementation that routes log entries to Android logcat
+// using the appropriate log priority for each LogLevel:
+//
+//   - VVERBOSE / VERBOSE / DEBUG = ANDROID_LOG_DEBUG
+//   - INFO                       = ANDROID_LOG_INFO
+//   - WARN                       = ANDROID_LOG_WARN
+//   - ERROR / STACKTRACE         = ANDROID_LOG_ERROR
+//   - USR                        = ANDROID_LOG_INFO
+type xlog struct{}
+
+var _ Console = (*xlog)(nil)
+var _ io.Writer = (*xlog)(nil)
+
+// NewAndroidConsole returns a Console that writes to Android logcat.
+func NewAndroidConsole() Console {
+	return &xlog{}
+}
+
+// Log implements Console.
+func (a *xlog) Log(level LogLevel, msg Logmsg) {
+	if len(msg) <= 0 {
+		return
+	}
+	cstr := C.CString(string(msg))
+	C.__android_log_write(androidPriority(level), ctag, cstr)
+	C.free(unsafe.Pointer(cstr))
+}
+
+func (a *xlog) Write(p []byte) (n int, err error) {
+	s := strings.TrimRight(string(p), "\n\r")
+	for line := range strings.SplitSeq(s, "\n") {
+		lvl, msg := splitmsg([]byte(line))
+		if len(msg) > 0 {
+			a.Log(lvl, msg)
+		}
+	}
+	return len(p), nil
+}
+
+// androidPriority maps a LogLevel to the corresponding Android log priority.
+func androidPriority(level LogLevel) C.int {
+	switch level {
+	case VVERBOSE, VERBOSE, DEBUG:
+		return C.ANDROID_LOG_DEBUG
+	case INFO, USR:
+		return C.ANDROID_LOG_INFO
+	case WARN:
+		return C.ANDROID_LOG_WARN
+	case ERROR, STACKTRACE:
+		return C.ANDROID_LOG_ERROR
+	default:
+		return C.ANDROID_LOG_DEBUG
+	}
+}

intra/log/xlog_other.go

@@ -0,0 +1,38 @@
+// Copyright (c) 2026 RethinkDNS and its authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+//go:build !(android && cgo)
+
+package log
+
+import (
+	"fmt"
+	"io"
+	"strings"
+)
+
+// xlog pipes logs to logcat on Android; to fmt.Print otherwise.
+type xlog struct{}
+
+var _ Console = (*xlog)(nil)
+var _ io.Writer = (*xlog)(nil)
+
+// Log implements Console.
+func (a *xlog) Log(level LogLevel, msg Logmsg) {
+	fmt.Printf("%s\n", msg)
+}
+
+// Write implements io.Writer.
+func (a *xlog) Write(p []byte) (n int, err error) {
+	s := strings.TrimRight(string(p), "\n\r")
+	for line := range strings.SplitSeq(s, "\n") {
+		lvl, msg := splitmsg([]byte(line))
+		if len(msg) > 0 {
+			a.Log(lvl, msg)
+		}
+	}
+	return len(p), nil
+}