Add Leak Check workflow to CI that uses Leak Sanitizer (rogchap#226)

* Add support for using Leak Sanitizer through a leakcheck build tag

* Exclude ExampleFunctionTemplate_fetch when leak checking on macOS

* Add leak check github action

* Add documentation for doing leak checking locally

* Improve backtrace to help with debugging reported leaks

The sanitizers are a part of LLVM, so using clang seems to result
in more complete backtraces. Doing a separate `go test -c` from
running the test executable was also needed to actually get line
numbers in the backtrace in CI. Disabling dwarf compression was
also needed on macOS

Co-authored-by: Genevieve <[email protected]>

Author: dylanahsmith

.github/workflows/leakcheck.yml

@@ -0,0 +1,27 @@
+name: Leak Check
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Install Go
+      uses: actions/setup-go@v2
+      with:
+        go-version: 1.17.2
+    - name: Checkout
+      uses: actions/checkout@v2
+    - name: Go Test
+      env:
+        CC: clang
+        CXX: clang++
+      run: |
+        go test -c --tags leakcheck
+        ./v8go.test

README.md

@@ -241,6 +241,37 @@ standard output being fully buffered.
 A simple way to avoid this problem is to flush the standard output stream after printing with the `fflush(stdout);` statement.
 Not relying on the flushing at exit can also help ensure the output is printed before a crash.
 
+### Local leak checking
+
+Leak checking is automatically done in CI, but it can be useful to do locally to debug leaks.
+
+Leak checking is done using the [Leak Sanitizer](https://clang.llvm.org/docs/LeakSanitizer.html) which
+is a part of LLVM. As such, compiling with clang as the C/C++ compiler seems to produce more complete
+backtraces (unfortunately still only of the system stack at the time of writing).
+
+For instance, on a Debian-based Linux system, you can use `sudo apt-get install clang-12` to install a
+recent version of clang.  Then CC and CXX environment variables are needed to use that compiler. With
+that compiler, the tests can be run as follows
+
+```
+CC=clang-12 CXX=clang++-12 go test -c --tags leakcheck && ./v8go.test
+```
+
+The separate compile and link commands are currently needed to get line numbers in the backtrace.
+
+On macOS, leak checking isn't available with the version of clang that comes with Xcode, so a separate
+compiler installation is needed.  For example, with homebrew, `brew install llvm` will install a version
+of clang with support for this. The ASAN_OPTIONS environment variable will also be needed to run the code
+with leak checking enabled, since it isn't enabled by default on macOS. E.g. with the homebrew
+installation of llvm, the tests can be run with
+
+```
+CXX=/usr/local/opt/llvm/bin/clang++ CC=/usr/local/opt/llvm/bin/clang go test -c --tags leakcheck -ldflags=-compressdwarf=false
+ASAN_OPTIONS=detect_leaks=1 ./v8go.test
+```
+
+The `-ldflags=-compressdwarf=false` is currently (with clang 13) needed to get line numbers in the backtrace.
+
 ### Formatting
 
 Go has `go fmt`, C has `clang-format`. Any changes to the `v8go.h|cc` should be formated with `clang-format` with the

function_template_fetch_test.go

@@ -0,0 +1,55 @@
+// Copyright 2021 Roger Chapman and the v8go contributors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Ignore leaks within Go standard libraries http/https support code.
+// The getaddrinfo detected leaks can be avoided using GODEBUG=netdns=go but
+// currently there are more for loading system root certificates on macOS.
+//go:build !leakcheck || !darwin
+// +build !leakcheck !darwin
+
+package v8go_test
+
+import (
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"strings"
+
+	v8 "rogchap.com/v8go"
+)
+
+func ExampleFunctionTemplate_fetch() {
+	iso := v8.NewIsolate()
+	defer iso.Dispose()
+	global := v8.NewObjectTemplate(iso)
+
+	fetchfn := v8.NewFunctionTemplate(iso, func(info *v8.FunctionCallbackInfo) *v8.Value {
+		args := info.Args()
+		url := args[0].String()
+
+		resolver, _ := v8.NewPromiseResolver(info.Context())
+
+		go func() {
+			res, _ := http.Get(url)
+			body, _ := ioutil.ReadAll(res.Body)
+			val, _ := v8.NewValue(iso, string(body))
+			resolver.Resolve(val)
+		}()
+		return resolver.GetPromise().Value
+	})
+	global.Set("fetch", fetchfn, v8.ReadOnly)
+
+	ctx := v8.NewContext(iso, global)
+	defer ctx.Close()
+	val, _ := ctx.RunScript("fetch('https://rogchap.com/v8go')", "")
+	prom, _ := val.AsPromise()
+
+	// wait for the promise to resolve
+	for prom.State() == v8.Pending {
+		continue
+	}
+	fmt.Printf("%s\n", strings.Split(prom.Result().String(), "\n")[0])
+	// Output:
+	// <!DOCTYPE html>
+}

function_template_test.go

@@ -6,9 +6,6 @@ package v8go_test
 
 import (
 	"fmt"
-	"io/ioutil"
-	"net/http"
-	"strings"
 	"testing"
 
 	v8 "rogchap.com/v8go"
@@ -127,38 +124,3 @@ func ExampleFunctionTemplate() {
 	// Output:
 	// [foo bar 0 1]
 }
-
-func ExampleFunctionTemplate_fetch() {
-	iso := v8.NewIsolate()
-	defer iso.Dispose()
-	global := v8.NewObjectTemplate(iso)
-
-	fetchfn := v8.NewFunctionTemplate(iso, func(info *v8.FunctionCallbackInfo) *v8.Value {
-		args := info.Args()
-		url := args[0].String()
-
-		resolver, _ := v8.NewPromiseResolver(info.Context())
-
-		go func() {
-			res, _ := http.Get(url)
-			body, _ := ioutil.ReadAll(res.Body)
-			val, _ := v8.NewValue(iso, string(body))
-			resolver.Resolve(val)
-		}()
-		return resolver.GetPromise().Value
-	})
-	global.Set("fetch", fetchfn, v8.ReadOnly)
-
-	ctx := v8.NewContext(iso, global)
-	defer ctx.Close()
-	val, _ := ctx.RunScript("fetch('https://rogchap.com/v8go')", "")
-	prom, _ := val.AsPromise()
-
-	// wait for the promise to resolve
-	for prom.State() == v8.Pending {
-		continue
-	}
-	fmt.Printf("%s\n", strings.Split(prom.Result().String(), "\n")[0])
-	// Output:
-	// <!DOCTYPE html>
-}

leak_test.go

@@ -0,0 +1,21 @@
+// Copyright 2021 the v8go contributors. 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 leakcheck
+// +build leakcheck
+
+package v8go_test
+
+import (
+	"testing"
+	"os"
+
+	"rogchap.com/v8go"
+)
+
+func TestMain(m *testing.M) {
+	exitCode := m.Run()
+	v8go.DoLeakSanitizerCheck()
+	os.Exit(exitCode)
+}

leakcheck.go

@@ -0,0 +1,23 @@
+// Copyright 2021 the v8go contributors. 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 leakcheck
+// +build leakcheck
+
+package v8go
+
+// #cgo CPPFLAGS: -fsanitize=address
+// #cgo LDFLAGS: -fsanitize=address
+//
+// #include <sanitizer/lsan_interface.h>
+import "C"
+
+import "runtime"
+
+// Call LLVM Leak Sanitizer's at-exit hook that doesn't
+// get called automatically by Go.
+func DoLeakSanitizerCheck() {
+	runtime.GC()
+	C.__lsan_do_leak_check()
+}