Hi,
Nice library, just what I'm looking for.

I've made a couple of minor tweaks that you may want to incorporate into future releases.

1. MIN_LEVEL_RELEASE_MODE

This sets a minimum log level when not running in debug mode (Export with Debug flag deselected).
Basically, it allows forcing the log level to something higher than you might have when running in debug mode (eg, only ERROR or FATAL).
My hacky implementation below...

#logger.gd
var MIN_LEVEL_RELEASE_MODE = "error"
func _set_loglevel(level:String):
    if OS.is_debug_build() == false:
        level = MIN_LEVEL_RELEASE_MODE

2. Adding call-site information to the log output (eg filename:function:line_no).

Again, a hacky solution to get the stack and output the line that called GodotLogger.info() (or .debug or whatever).
No performance testing what so ever... (I don't know what the performance implications of calling get_stack() are, but I don't expect it'd be good...

Output is something like:
INFO [22/11/2023 07:03:21][my_level.gd:generate_level:123] Generated Room: 0

#logger.gd
func _return_callsite_from_stack(stack) -> String:
	if stack == null: # null in release mode
		return "" 

	if stack.size() < 3: # just to be sure
		return ""

	var callsite = stack[2] # third item in the stack is where it was called from
	var format_str = "[{file}:{func}:{line}]"
	var callsite_file_split = callsite.source.rsplit("/") # just get the filename to save chars on the logging line
	return format_str.format({
		"file": callsite_file_split[callsite_file_split.size() -1],
		"func": callsite.function,
		"line": callsite.line,
	})

#existing func
func logger(message:String,values,log_level=LogLevel.INFO):
	if CURRENT_LOG_LEVEL > log_level :
		return
	var log_msg_format = "{level} [{time}]{call_site}{prefix} {message} " #added {call_site}

	var now = Time.get_datetime_dict_from_system(true)

	var msg = log_msg_format.format(
		{
			"prefix":_prefix,
			"message":message,
			"time":"{day}/{month}/{year} {hour}:{minute}:{second}".format(now),
			"level":LogLevel.keys()[log_level],
			"call_site": _return_callsite_from_stack(get_stack()) # populate call_site
		})

Hope someone finds that useful :)

When logging ints, floats, booleans and null, their types are not preserved and instead they are converted to strings.

This code:

class InventoryItem extends Resource:
	@export var itemtype: int = 0
	@export var metadata: Dictionary = {}
	@export var quantity: int = 1


func _ready():
	var d = {
		"foobar": "bazqux",
		5: 25,
		3.14: 12e3,
		true: false,
		null: null,
		"an object": InventoryItem.new(),
	}
	GodotLogger.info("this is an array", d)

results in the following output:
INFO [21/9/2023 22:57:53] this is an array {"foobar":"bazqux","5":"25","3.14":"12000","true":"false","<null>":"<null>","an object":"{"itemtype":0,"metadata":{},"quantity":1,"resource_local_to_scene":false,"resource_name":"","resource_path":""}"}

Each of these lines result in a "Invalid operands" crash.

	GodotLogger.info("this is an integer", 7)
	GodotLogger.info("this is a float", 3.14)
	GodotLogger.info("this is a bool", true)

Hi there,

I noticed the version of this plugin in the godot assetlib is out of date. Could I ask you to update it to the most recent version? It's still on a version from last october.

Thank you!

In passing, this is likely overkill but an option for auto-updating would be: https://github.com/myyk/godot-plugin-updater

Logging a null prevents the line from being printed. Any null object or array also results in the line not printing. Is that intended behavior? I would prefer that a log line prints even if the value I pass is null.

The following line prints nothing:
GodotLogger.info("this is a null", null)

Arrays are not being logged correctly (I mean to say, aren't valid json) - strings end up missing quotes, the brackets are replaced with curly braces, there are no commas, and nulls show up as <null>.

GodotLogger.info("this is an array", ["foobar", 5, 3.14, false, null])

results in

INFO [21/9/2023 22:42:34] this is an array {foobar53.14false<null}

I'm implementing an external log window for when my project runs without the editor, and would like to use your addon for my logging needs. But in order for the log window to pick up the messages sent to the log messages a signal would be in order. I can of course just add it to my instance of the addon, but thought it would be something that more people would benefit from. Would you mind me adding this to your addon?

Summary

The stack trace included on all logs coming from GodotLogger.debug() is always: At: res://addons/logger/logger.gd:95:logger()

Expected Behavior

The stack trace on debug level logs should reflect the point at which the call to debug() took place.

The Godot Asset Library lists your asset as MIT licensed, but this Github repo's LICENSE file says it's GPL-3.0. While both are open source, these two licenses are very different, as one is copyleft and the other is permissive. Please clarify which license you really want:

• If you want to make sure anyone who uses this code must make their Godot game's source code available also under GPL-3.0 or compatible license, please update the Godot Asset Library and list it as GPL-3.0 (or remove it from the Asset Library).

• If you want people to have maximum freedom, in your next version please update the LICENSE file of this Github repo to the MIT license text.

Whenever GodotLogger.with() is used, an orphan node is created, leading to a (small) memory leak

Here is a patch that fixed the issue for me :

diff --git a/addons/logger/logger.gd b/addons/logger/logger.gd
index 4b8ee65b1..db4feef3d 100644
--- a/addons/logger/logger.gd
+++ b/addons/logger/logger.gd
@@ -44,12 +44,10 @@ func _set_loglevel(level:String):
 			CURRENT_LOG_LEVEL = LogLevel.FATAL
 
 func with(prefix:String="",args:Dictionary={}) ->Log :
-	var l = Log.new()
-	l.CURRENT_LOG_LEVEL = self.CURRENT_LOG_LEVEL
-	l._prefix = prefix
+	self._prefix = prefix
 	for k in args:
-		l._default_args[k] = args[k]
-	return l
+		self._default_args[k] = args[k]
+	return self
 
 func logger(message:String,values,log_level=LogLevel.INFO):
 	if CURRENT_LOG_LEVEL > log_level :