jint: Memory leak in V3?

Hi,

I am currently using v2 without any issues, but I just tried to use 3.0.0-beta-2044 in my software to take advantage at all the improvements. But unfortunately after the change, the software is hogging memory. Clearly it has something to do with v3.

Background The software is my own home automation software where devices have a state determination script (javascript) which gets evaluated every minute or when there’s a change in a datasource it uses (eg a switch).

This is done by looping over the devices and evaluate it’s script (per scenario (day, night, away) it has it’s own functions in the script.

I have written a helper that makes some thing easy by adding helper classes and enums to the context (static functions):

    public static Engine GetEngine()
    {
        var engine = new Engine()
            .SetValue("Log", new Action<string>(p => GetServiceProvider.GetServiceOrCreateInstance<ILogger<JavascriptEvaluator>>().LogInformation(p)))
            .SetValue("Settings", GetServiceProvider.GetServiceOrCreateInstance<Settings>())
            .SetValue("Cache", GetServiceProvider.GetServiceOrCreateInstance<Cacher>());

        engine.SetValue("$", new JavascriptTools(engine));

        // Add all enums
        AppDomain.CurrentDomain.GetAssemblies()
            .Where(a => a.FullName?.StartsWith("MyNamespace") == true)
            .SelectMany(a =>
                a.GetTypes().Where(t => t.IsEnum && t.IsPublic))
            .OrderBy(t => t.Name)
            .ForEach(e => engine.SetValue(e.Name, TypeReference.CreateTypeReference(engine, e)));

        return engine;
    }

And here’s the evaluate function (EvaluateFunction) which gets called multiple times a minute (around 50 times) and another evaluate function that is called by some scheduled tasks.

    public static T Evaluate<T>(string script, object variables = null)
    {
        if (string.IsNullOrEmpty(script)) return default;
        
        var engine = GetEngine();
        PopulateVariables(engine, variables);

        var result = engine.Evaluate(script)
            .ToObject();
        
        engine.Dispose();

        return (T)Convert.ChangeType(result, typeof(T));
    }

    private static void PopulateVariables(Engine engine, object variables)
    {
        if (variables is Dictionary<string, object> dictionary)
            dictionary.ForEach(p => engine.SetValue(p.Key, p.Value));
        else
            variables?.GetType()
                .GetProperties()
                .Where(p => p.GetIndexParameters().Length == 0)
                .ForEach(p => { engine.SetValue(p.Name, p.GetValue(variables)); });
    }

    public static T EvaluateFunction<T>(string script, string function, params object[] parameters)
    {
        if (string.IsNullOrEmpty(script)) return default;

        if (!script.Contains(function)) throw new UndefinedJavascriptFunctionException(function);

        var engine = GetEngine();
        var result = engine
            .Execute(script)
            .Invoke(function, parameters)
            .ToObject();
        
        engine.Dispose();

        return (T)Convert.ChangeType(result, typeof(T));
    }

The GetServiceProvider.GetServiceOrCreateInstance function basically gets the instance of a singleton via DPI. JavascriptTools is a class that adds functions to use in the script, which has subtools for eg. devices and datasources.

Issue Memory keeps increasing over time (hour to two hours it leaks around 400MB) even though disposing the engine. I am surely missing something simple at the moment but can’t quite put my finger on it.

The app is running in a docker container so remote debugging is quite the hassle. But I am certain it has something to do with V3 as V2 is rock stable when it comes to memory usage.

Any ideas?