gdharness 0.13.41 → 0.13.43

package/build/godot/addons/gdharness_runtime/error_report.gd

@@ -0,0 +1,62 @@
+extends Logger
+
+## Every error the engine reports inside this game, written to a file beside the announcement,
+## in the lines the engine itself prints to stderr.
+##
+## A game the editor plays prints to the editor's own stderr, which nobody reads: a `push_error`
+## raised in one reached neither `editor_output` nor the run's transcript, and the run was
+## answered clean while the game had just refused something out loud. The debug adapter relays
+## what the game prints and not what it reports, so the report is taken where it is made, in
+## the game, and left where the server already looks. The lines are the engine's own so the
+## server reads them the way it reads a run it started itself.
+
+var _path: String
+
+
+func _init(path: String) -> void:
+	_path = path
+
+
+# The engine's own signature for a Logger, eight parameters and not this project's to shape.
+# gdlint:ignore = function-arguments-number
+func _log_error(
+	function: String,
+	file: String,
+	line: int,
+	code: String,
+	rationale: String,
+	_editor_notify: bool,
+	error_type: int,
+	script_backtraces: Array[ScriptBacktrace],
+) -> void:
+	var kind: String
+	match error_type:
+		ERROR_TYPE_WARNING:
+			kind = "WARNING"
+		ERROR_TYPE_SCRIPT:
+			kind = "SCRIPT ERROR"
+		ERROR_TYPE_SHADER:
+			kind = "SHADER ERROR"
+		_:
+			kind = "ERROR"
+	var lines: Array[String] = [
+		"%s: %s" % [kind, rationale if not rationale.is_empty() else code],
+		"   at: %s (%s:%d)" % [function, file, line],
+	]
+	for backtrace: ScriptBacktrace in script_backtraces:
+		lines.append(backtrace.format(3))
+	# Opened for each report rather than held, so the file is whole on disk after every one:
+	# the last error a game reports is the one a caller most needs, and the game may be gone the
+	# moment after. Nothing here may report an error of its own, which would come straight back.
+	var report: FileAccess = (
+		FileAccess.open(_path, FileAccess.READ_WRITE)
+		if FileAccess.file_exists(_path)
+		else FileAccess.open(_path, FileAccess.WRITE)
+	)
+	if report == null:
+		return
+	report.seek_end()
+	for each: String in lines:
+		# A line the disk would not take is a report lost, and nothing here may report that.
+		var _stored: bool = report.store_line(each)
+	report.close()

package/build/godot/addons/gdharness_runtime/error_report.gd.uid

@@ -0,0 +1 @@
+uid://bhvig6uq5tvey

package/build/godot/addons/gdharness_runtime/runtime_autoload.gd

@@ -11,6 +11,7 @@ extends Node
 ## id and the reply carries it back.
 
 const Capture = preload("runtime_capture.gd")
+const ErrorReport = preload("error_report.gd")
 const InputCommands = preload("runtime_input.gd")
 const Queries = preload("runtime_queries.gd")
 const Read = preload("reading.gd")
@@ -36,6 +37,11 @@ const SCRIPT_RUNS_SETTING: String = "gdharness/runtime/serve_script_runs"
 ## `EDITOR_PID_VARIABLE` in the editor addon's bridge client.
 const EDITOR_PID_VARIABLE: String = "GDHARNESS_EDITOR_PID"
 
+## The file the engine's error reports go to, beside the announcement and named the same way,
+## which is where the server reads them for a run the editor plays. Kept in step with
+## `errorReportPath` in src/runtime-client.ts.
+const ERROR_REPORT_NAME: String = "runtime-%d.log"
+
 var values: Values = Values.new()
 
 # The modules are members and not locals of _init, because a Callable holds its object by id
@@ -61,6 +67,9 @@ var _outgoing: Dictionary = {}
 var _port: int = 0
 var _enabled: bool = true
 var _announcement: String = ""
+## Held for as long as the game runs: a Logger the engine has is kept by reference, and one
+## that goes away mid-run takes the report with it.
+var _errors: ErrorReport
 ## Every command, by the name a request uses, as the module method that answers it.
 var _commands: Dictionary = {}
 
@@ -98,13 +107,35 @@ func _ready() -> void:
 	# even be un-paused over the socket. A debug server has to stay responsive while the game
 	# is frozen, to inspect, capture, inject or resume it.
 	process_mode = Node.PROCESS_MODE_ALWAYS
+	_report_errors()
 	_start_server()
 
 
 func _exit_tree() -> void:
+	if _errors != null:
+		OS.remove_logger(_errors)
+		_errors = null
 	_cleanup()
 
 
+## The engine's error reports, written to a file for the server, for a game the editor plays.
+##
+## Only for one the editor plays: a game the server starts itself has its stderr in the run's
+## transcript already, and a game somebody runs from a terminal has it on the terminal. The
+## editor's game prints to the editor's stderr, which nobody reads, and the editor's debug
+## adapter relays what the game prints and not what it reports. Before the server starts, so
+## a port that cannot be bound is reported there too, and whether or not the server comes up.
+func _report_errors() -> void:
+	if not OS.get_environment(EDITOR_PID_VARIABLE).is_valid_int():
+		return
+	var directory: String = _announcement_directory()
+	var made: Error = DirAccess.make_dir_recursive_absolute(directory)
+	if made != OK and made != ERR_ALREADY_EXISTS:
+		return
+	_errors = ErrorReport.new(directory.path_join(ERROR_REPORT_NAME % OS.get_process_id()))
+	OS.add_logger(_errors)
+
+
 func _process(_delta: float) -> void:
 	if not _enabled or _server == null:
 		return