feat: relocate js sdk to merge

feat: separate adapter and collector, add demangling

feat: add datadog adapter, re-export from sdk

feat: implement support for allocation tracking

chore: centralize util id functions

fix: update import paths

chore: remove span collector id

fix: add modsurfer-demangle to the repo

fix: correct trace endpoint, address pr feedback

fix: duration correction

chore: remove name truncation

fix: use put for datadog request

feat: Produce bundles for Deno & Node

feat: add web build

feat: create separate npm packages for datadog and stdout adapters

feat: create separate npm packages for datadog and stdout adapters

fix: support allocation tracing attached to functions (#4)

* fix: support allocation tracing attached to functions

* chore: include additional wasm module for testing

* test: update tests to use other wasm

* fix: update package.json to use new tests

chore: gen build files

chore: commit build files

fix: node test

chore: create packages directory

chore: use package name as directory name

feat: parse custom name section without wasm-parser, create universal distributables

chore: package cleanup

chore: remove dist

chore: relocate js sdk to merge

Co-Authored-By: Rob Wong <rob@dylibso.com>

.gitignore → js/.gitignore

@@ -1,3 +1,6 @@
 rust/target
 rust/Cargo.lock
+.vscode
 target
+**/node_modules
+**/dist

README.md → js/README.md

@@ -1,3 +1,4 @@
+<<<<<<< HEAD
 # Observe
 
 Observe provides observability SDKs for WebAssembly, enabling continuous monitoring of WebAssembly code as it executes within a runtime. 
@@ -129,3 +130,10 @@ make instrument WASM_INSTR_API_KEY=<your-api-key>
 One of the test adapters will output to Zipkin, defaulting to one running on localhost.
 
     docker run -d -p 9411:9411 openzipkin/zipkin
+=======
+# Observe JS SDK
+
+```sh
+echo "this is a test" | deno run -A bin/stdout.ts
+```
+>>>>>>> b49b316 (init)

js/esbuild/esbuild.js

@@ -0,0 +1,87 @@
+const esbuild = require('esbuild');
+const path = require('path');
+const fs = require('fs');
+const { program } = require('commander');
+
+let wasmPlugin = {
+    name: 'wasm',
+    setup(build) {
+        // Resolve ".wasm" files to a path with a namespace
+        build.onResolve({ filter: /\.wasm$/ }, args => {
+            // If this is the import inside the stub module, import the
+            // binary itself. Put the path in the "wasm-binary" namespace
+            // to tell our binary load callback to load the binary file.
+            if (args.namespace === 'wasm-stub') {
+                return {
+                    path: args.path,
+                    namespace: 'wasm-binary',
+                }
+            }
+
+            // Otherwise, generate the JavaScript stub module for this
+            // ".wasm" file. Put it in the "wasm-stub" namespace to tell
+            // our stub load callback to fill it with JavaScript.
+            //
+            // Resolve relative paths to absolute paths here since this
+            // resolve callback is given "resolveDir", the directory to
+            // resolve imports against.
+            if (args.resolveDir === '') {
+                return // Ignore unresolvable paths
+            }
+            return {
+                path: path.isAbsolute(args.path) ? args.path : path.join(args.resolveDir, args.path),
+                namespace: 'wasm-stub',
+            }
+        })
+
+        // Virtual modules in the "wasm-stub" namespace are filled with
+        // the JavaScript code for compiling the WebAssembly binary. The
+        // binary itself is imported from a second virtual module.
+        build.onLoad({ filter: /.*/, namespace: 'wasm-stub' }, async (args) => ({
+            contents: `import wasm from ${JSON.stringify(args.path)}
+          export default (imports) =>
+            WebAssembly.instantiate(wasm, imports).then(
+              result => result.instance.exports)`,
+        }))
+
+        // Virtual modules in the "wasm-binary" namespace contain the
+        // actual bytes of the WebAssembly file. This uses esbuild's
+        // built-in "binary" loader instead of manually embedding the
+        // binary data inside JavaScript code ourselves.
+        build.onLoad({ filter: /.*/, namespace: 'wasm-binary' }, async (args) => ({
+            contents: await fs.promises.readFile(args.path),
+            loader: 'binary',
+        }))
+    },
+}
+
+// parse cli input
+program
+    .option('-e, --entrypoint <string>')
+    .option('-b, --bundle')
+    .option('-o, --outfile <string>')
+    .option('-p, --platform <string>')
+    .option('-f, --format <string>')
+    .option('-g, --generateTypes')
+program.parse();
+
+const options = program.opts();
+
+// conditional logic for polyfilling deno
+const plugins = [
+    wasmPlugin,
+]
+
+esbuild.build({
+    entryPoints: [options.entrypoint],
+    bundle: options.bundle,
+    // minify: true,
+    allowOverwrite: true,
+    outfile: options.outfile,
+    platform: options.platform,
+    format: options.format,
+    // loader: {
+    //     '.data': 'binary'
+    // },
+    plugins,
+})