dd-trace-bun 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,124 @@
-# Temporary Holding Version
+# dd-trace-bun
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Datadog APM for Bun servers. It makes [dd-trace](https://github.com/DataDog/dd-trace-js) trace `Bun.serve`, and so Elysia, Hono and anything else built on it, so that traces coming from your other services (Node, Go, Python, …) **continue into your Bun service instead of starting over**.
+
+It sits on top of dd-trace rather than replacing it: outbound `fetch`, `node:http`, Express and the database clients dd-trace already instruments in Bun keep working, and spans reach the Datadog agent exactly as they do from Node.
+
+## Why
+
+dd-trace's HTTP server integration hooks Node's `http.Server`. `Bun.serve` is native and never goes through it, so with plain dd-trace in Bun ([dd-trace-js#3749](https://github.com/DataDog/dd-trace-js/issues/3749)):
+
+- requests handled by `Bun.serve`, Elysia or Hono get no server span
+- incoming `x-datadog-*` / `traceparent` headers are never read
+- every span created in a handler starts a new trace
+
+## Install
+
+```sh
+bun add dd-trace dd-trace-bun
+```
+
+## Usage
+
+No code changes needed. Preload it and configure dd-trace with the usual `DD_*` environment variables:
+
+```sh
+DD_SERVICE=users-api DD_ENV=prod bun --preload dd-trace-bun/init src/index.ts
+```
+
+Or initialise it in code before your server starts. `init()` takes the same options as dd-trace's `tracer.init()` and returns the tracer:
+
+```ts
+import { init } from 'dd-trace-bun'
+
+const tracer = init({ service: 'users-api' })
+```
+
+### Elysia
+
+`.listen()` is traced as is. Elysia serves most routes through Bun's native `routes`, so their spans are already named by route template (`GET /users/:id`). The plugin names the rest (`.all()`, optional parameters, …) and attaches handler errors to spans. Register it before your routes, because Elysia applies hooks only to routes added after them:
+
+```ts
+import { Elysia } from 'elysia'
+import { datadog } from 'dd-trace-bun/elysia'
+
+new Elysia()
+  .use(datadog())
+  .get('/users/:id', ({ params }) => ({ id: params.id }))
+  .listen(3000)
+```
+
+### Other frameworks
+
+Anything that ends up in `Bun.serve` is traced, including a default export Bun serves for you. Three functions let a framework integration do more:
+
+- `setRoute(request, '/users/:id')` names the request's span after its route template.
+- `recordError(request, error)` attaches an error to the span. As in dd-trace's own framework integrations, the span is only marked as an error if the response status is one (5xx by default).
+- `traceHandler(fetch)` traces a fetch handler that doesn't go through `Bun.serve`.
+
+## Configuration
+
+Requests go through **dd-trace's own `http` server plugin**, the code that handles `node:http` on Node, so everything is configured as it is there and behaves the same:
+
+```ts
+tracer.use('http', {
+  server: {
+    blocklist: ['/healthz'],
+    validateStatus: (code) => code < 500,
+    hooks: { request: (span, req) => span?.setTag('tenant', req?.headers['x-tenant']) },
+    service: 'users-http',
+  },
+})
+```
+
+Environment variables such as `DD_TRACE_HEADER_TAGS`, `DD_TRACE_HTTP_SERVER_ERROR_STATUSES`, `DD_TRACE_PROPAGATION_STYLE`, `DD_TRACE_SPAN_ATTRIBUTE_SCHEMA`, `DD_TRACE_OTEL_SEMANTICS_ENABLED`, `DD_TRACE_CLIENT_IP_ENABLED` and `DD_TRACE_RESOURCE_RENAMING_ENABLED` all apply. In hooks, `req` is a Node-style view of the Bun request (`method`, `url`, `headers`, `socket.remoteAddress`) with the original `Request` on `req.request`.
+
+**AppSec** works too (`DD_APPSEC_ENABLED=true`): attacks are reported on the span, and requests that match a blocking rule get dd-trace's blocking response without reaching your handler.
+
+## Parity with dd-trace on Node
+
+`test/parity/http-server.test.ts` ports dd-trace-js's own `packages/datadog-plugin-http/test/server.spec.js`, plus propagation, AppSec and web-util behaviour other dd-trace specs cover. It runs the **same assertions** against three apps:
+
+| App | Runtime | Tracer | Result |
+|---|---|---|---|
+| `node:http` (reference) | Node 22 | plain dd-trace | 28 / 28 |
+| `Bun.serve` | Bun 1.4.2 | dd-trace-bun | 28 / 28 |
+| Elysia `.listen()` | Bun 1.4.2 | dd-trace-bun | 28 / 28 |
+
+The cases cover span shape (name, service, type, resource, kind, URL, method, status, component), the request scope, Datadog / W3C / B3 propagation, 5xx and thrown errors, query string obfuscation, CORS preflight trace headers, canceled requests, OTel semantics, `DD_TRACE_HTTP_SERVER_ERROR_STATUSES`, `server` config, hooks, blocklist and `service` override, a disabled server integration, resource renaming (`http.endpoint`), header tags, client IP, naming schema v1, and AppSec reporting and blocking. Elysia spans carry its matched route (`GET /*`), as dd-trace's Express integration does, so its resource and endpoint assertions expect the route.
+
+`test/serve.test.ts` covers what only Bun has: native `routes`, `server.reload()`, WebSocket upgrades, class-based options, Elysia's client errors, and `node:http` in Bun still being traced once.
+
+## How it works
+
+- `init()` patches `Bun.serve` (and `server.reload`) to wrap `fetch` and every handler in `routes`.
+- Each request is published on the diagnostics channels dd-trace's `node:http` instrumentation uses, with a Node-style view of the request and response. dd-trace's http server plugin then extracts the incoming context, starts the span, applies its configuration, and finishes the span once the handler's `Response` is known. The span is active for the whole handler, across `await`s.
+- Handlers of Bun's native `routes` set `http.route`, so the resource becomes `GET /users/:id`.
+- What it needs from dd-trace beyond its public API (four channel names and `plugins/util/web`) is all in `src/internals.ts`. CI runs the suite against the newest dd-trace 5 and 6, so a dd-trace release that changes them shows up as a failing build. If they're missing at runtime, `init()` logs a warning and leaves `Bun.serve` alone instead of failing.
+
+## Limitations
+
+- The span ends when the handler returns its `Response`, not when a streamed body finishes.
+- When a bare `Bun.serve` fetch handler throws, the span records the error with status 500. Bun doesn't pass the request to your `error()` handler, so a different status it returns isn't seen. Elysia and Hono handle errors themselves and aren't affected.
+- dd-trace's runtime metrics crash Bun ([oven-sh/bun#18546](https://github.com/oven-sh/bun/issues/18546)), so `init()` keeps them off even if `DD_RUNTIME_METRICS_ENABLED` is set, and logs that it did. Passing `runtimeMetrics` to `init()` overrides this.
+- dd-trace's Orchestrion-based integrations (graphql, ai, bullmq, langchain, …) don't run under Bun ([dd-trace-js#3749](https://github.com/DataDog/dd-trace-js/issues/3749)). That's a gap in dd-trace itself, which this package doesn't address.
+- Inside `bun test`, dd-trace turns itself into a no-op because it sees Bun's jest-compatible globals. This package's own tests therefore run the traced apps as subprocesses.
+
+## Compatibility
+
+Bun ≥ 1.2.23, dd-trace ≥ 5.60 and < 7, and optionally Elysia ≥ 1.2. The whole suite passes on Bun 1.2.23, 1.3.0 and 1.4.2, dd-trace 5.131.1 and 6.20.1, and Elysia 1.2.25, 1.3.21 and 1.4.30. On dd-trace 5.60.0 and 6.0.0 Bun behaves exactly like Node, but some options the suite checks didn't exist yet. The floors are the oldest versions tested; further back, dd-trace itself breaks under Bun with or without this package (5.0.0 overflows the stack, and 6.20.1 fails to load on Bun 1.2.3).
+
+## Development
+
+```sh
+bun install
+bun test          # 97 tests against a fake Datadog agent; node must be on PATH for the reference app
+bun run typecheck
+bun run build     # compiles src/ to dist/, which is what the npm package exports
+```
+
+Releases are managed with [Changesets](https://github.com/changesets/changesets). A pull request that should ship a release adds a changeset with `bunx changeset`, which asks for the bump (patch, minor or major) and a line for the changelog. Once that's merged, CI opens or updates a "Version Packages" pull request that bumps `version` and CHANGELOG.md, and merging that one publishes to npm with provenance, tags the release and creates a GitHub release. Publishing needs an `NPM_TOKEN` repository secret, or npm trusted publishing set up for this repository.
+
+## License
+
+Apache-2.0, like dd-trace.

package/dist/elysia.d.ts

@@ -0,0 +1,9 @@
+import { Elysia } from 'elysia';
+/**
+ * Elysia plugin: names spans after the matched route (`GET /users/:id`) and attaches
+ * errors to them. Elysia already serves most routes through Bun's native `routes`, which
+ * `init()` names on its own; this covers the rest (e.g. `.all()` and optional params) and
+ * errors. Register it before your routes: Elysia applies hooks only to routes added after.
+ */
+export declare const datadog: () => Elysia;
+//# sourceMappingURL=elysia.d.ts.map

package/dist/elysia.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elysia.d.ts","sourceRoot":"","sources":["../src/elysia.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAG/B;;;;;GAKG;AACH,eAAO,MAAM,OAAO,QAAO,MAOrB,CAAA"}

package/dist/elysia.js

@@ -0,0 +1,16 @@
+import { Elysia } from 'elysia';
+import { recordError, setRoute } from "./serve.js";
+/**
+ * Elysia plugin: names spans after the matched route (`GET /users/:id`) and attaches
+ * errors to them. Elysia already serves most routes through Bun's native `routes`, which
+ * `init()` names on its own; this covers the rest (e.g. `.all()` and optional params) and
+ * errors. Register it before your routes: Elysia applies hooks only to routes added after.
+ */
+export const datadog = () => new Elysia({ name: 'dd-trace-bun' })
+    .onTransform({ as: 'global' }, ({ request, route }) => {
+    setRoute(request, route);
+})
+    .onError({ as: 'global' }, ({ request, error }) => {
+    recordError(request, error);
+});
+//# sourceMappingURL=elysia.js.map

package/dist/elysia.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"elysia.js","sourceRoot":"","sources":["../src/elysia.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAElD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,GAAW,EAAE,CAClC,IAAI,MAAM,CAAC,EAAE,IAAI,EAAE,cAAc,EAAE,CAAC;KACjC,WAAW,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE;IACpD,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;AAC1B,CAAC,CAAC;KACD,OAAO,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE;IAChD,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;AAC7B,CAAC,CAAC,CAAA"}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import tracer from 'dd-trace';
+import type { TracerOptions } from 'dd-trace';
+export { recordError, setRoute, traceHandler } from './serve.ts';
+/**
+ * Initialise dd-trace and instrument `Bun.serve`, and with it Elysia, Hono and anything
+ * else built on it. Call it before your server starts, or preload `dd-trace-bun/init`.
+ * Takes the same options as dd-trace's `tracer.init()`.
+ *
+ * Requests go through dd-trace's own http server plugin, so they're configured exactly as
+ * on Node: `tracer.use('http', { server: { ... } })` and the `DD_*` environment variables.
+ */
+export declare function init(options?: TracerOptions): typeof tracer;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,UAAU,CAAA;AAC7B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAI7C,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAEhE;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAAE,OAAO,GAAE,aAAkB,GAAG,OAAO,MAAM,CAiBhE"}

package/dist/index.js

@@ -0,0 +1,33 @@
+import tracer from 'dd-trace';
+import { web } from "./internals.js";
+import { patchBunServe } from "./serve.js";
+export { recordError, setRoute, traceHandler } from "./serve.js";
+/**
+ * Initialise dd-trace and instrument `Bun.serve`, and with it Elysia, Hono and anything
+ * else built on it. Call it before your server starts, or preload `dd-trace-bun/init`.
+ * Takes the same options as dd-trace's `tracer.init()`.
+ *
+ * Requests go through dd-trace's own http server plugin, so they're configured exactly as
+ * on Node: `tracer.use('http', { server: { ... } })` and the `DD_*` environment variables.
+ */
+export function init(options = {}) {
+    if (typeof Bun === 'undefined')
+        return tracer.init(options);
+    if (options.runtimeMetrics === undefined && isTrue(process.env.DD_RUNTIME_METRICS_ENABLED)) {
+        console.warn('dd-trace-bun: ignoring DD_RUNTIME_METRICS_ENABLED, dd-trace\'s runtime metrics crash Bun ' +
+            '(https://github.com/oven-sh/bun/issues/18546). Pass `runtimeMetrics` to init() to override.');
+    }
+    tracer.init({ ...options, runtimeMetrics: options.runtimeMetrics ?? false });
+    if (!web) {
+        console.warn('dd-trace-bun: the installed dd-trace version is not supported, Bun.serve requests will not be traced.');
+        return tracer;
+    }
+    // dd-trace starts its http plugin, which turns these requests into spans, once node:http is loaded
+    require('node:http');
+    patchBunServe();
+    return tracer;
+}
+function isTrue(value) {
+    return value === '1' || value?.toLowerCase() === 'true';
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,UAAU,CAAA;AAE7B,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAA;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE1C,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAEhE;;;;;;;GAOG;AACH,MAAM,UAAU,IAAI,CAAE,UAAyB,EAAE;IAC/C,IAAI,OAAO,GAAG,KAAK,WAAW;QAAE,OAAO,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IAE3D,IAAI,OAAO,CAAC,cAAc,KAAK,SAAS,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,0BAA0B,CAAC,EAAE,CAAC;QAC3F,OAAO,CAAC,IAAI,CAAC,2FAA2F;YACtG,6FAA6F,CAAC,CAAA;IAClG,CAAC;IACD,MAAM,CAAC,IAAI,CAAC,EAAE,GAAG,OAAO,EAAE,cAAc,EAAE,OAAO,CAAC,cAAc,IAAI,KAAK,EAAE,CAAC,CAAA;IAE5E,IAAI,CAAC,GAAG,EAAE,CAAC;QACT,OAAO,CAAC,IAAI,CAAC,uGAAuG,CAAC,CAAA;QACrH,OAAO,MAAM,CAAA;IACf,CAAC;IACD,mGAAmG;IACnG,OAAO,CAAC,WAAW,CAAC,CAAA;IACpB,aAAa,EAAE,CAAA;IACf,OAAO,MAAM,CAAA;AACf,CAAC;AAED,SAAS,MAAM,CAAE,KAAyB;IACxC,OAAO,KAAK,KAAK,GAAG,IAAI,KAAK,EAAE,WAAW,EAAE,KAAK,MAAM,CAAA;AACzD,CAAC"}

package/dist/init.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=init.d.ts.map

package/dist/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../src/init.ts"],"names":[],"mappings":""}

package/dist/init.js

@@ -0,0 +1,4 @@
+// `bun --preload dd-trace-bun/init src/index.ts`, configured with the DD_* environment variables.
+import { init } from "./index.js";
+init();
+//# sourceMappingURL=init.js.map

package/dist/init.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.js","sourceRoot":"","sources":["../src/init.ts"],"names":[],"mappings":"AAAA,kGAAkG;AAClG,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAEjC,IAAI,EAAE,CAAA"}

package/dist/internals.d.ts

@@ -0,0 +1,16 @@
+import dc from 'node:diagnostics_channel';
+import type { Span } from 'dd-trace';
+export declare const requestStart: dc.Channel<any, any>;
+export declare const requestExit: dc.Channel<any, any>;
+export declare const requestFinish: dc.Channel<any, any>;
+export declare const responseWriteHead: dc.Channel<any, any>;
+/** The parts of dd-trace's `plugins/util/web`, the request context all its web integrations share. */
+interface WebUtil {
+    root(req: object): Span | null;
+    setRoute(req: object, path: string): void;
+    addError(req: object, error: unknown): void;
+}
+/** Undefined when the installed dd-trace doesn't have the expected internals. */
+export declare const web: WebUtil | undefined;
+export {};
+//# sourceMappingURL=internals.d.ts.map

package/dist/internals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internals.d.ts","sourceRoot":"","sources":["../src/internals.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,MAAM,0BAA0B,CAAA;AAEzC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,UAAU,CAAA;AAEpC,eAAO,MAAM,YAAY,sBAA8C,CAAA;AACvE,eAAO,MAAM,WAAW,sBAA6C,CAAA;AACrE,eAAO,MAAM,aAAa,sBAA+C,CAAA;AACzE,eAAO,MAAM,iBAAiB,sBAAyD,CAAA;AAEvF,sGAAsG;AACtG,UAAU,OAAO;IACf,IAAI,CAAE,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAA;IAC/B,QAAQ,CAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1C,QAAQ,CAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAA;CAC7C;AAED,iFAAiF;AACjF,eAAO,MAAM,GAAG,EAAE,OAAO,GAAG,SAAyB,CAAA"}

package/dist/internals.js

@@ -0,0 +1,26 @@
+// Everything dd-trace-bun takes from dd-trace that isn't public API.
+//
+// Bun.serve requests are published on the diagnostics channels dd-trace's node:http
+// server instrumentation uses (packages/datadog-instrumentations/src/http/server.js),
+// so dd-trace's http server plugin and AppSec handle them exactly like node:http
+// requests. CI runs the test suite against the newest dd-trace 5 and 6 releases, so a
+// change to any of this shows up as a failing build.
+import dc from 'node:diagnostics_channel';
+import { createRequire } from 'node:module';
+export const requestStart = dc.channel('apm:http:server:request:start');
+export const requestExit = dc.channel('apm:http:server:request:exit');
+export const requestFinish = dc.channel('apm:http:server:request:finish');
+export const responseWriteHead = dc.channel('apm:http:server:response:writeHead:start');
+/** Undefined when the installed dd-trace doesn't have the expected internals. */
+export const web = loadWebUtil();
+function loadWebUtil() {
+    try {
+        const util = createRequire(import.meta.url)('dd-trace/packages/dd-trace/src/plugins/util/web');
+        const complete = ['root', 'setRoute', 'addError'].every((name) => typeof util[name] === 'function');
+        return complete ? util : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=internals.js.map

package/dist/internals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internals.js","sourceRoot":"","sources":["../src/internals.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,EAAE;AACF,oFAAoF;AACpF,sFAAsF;AACtF,iFAAiF;AACjF,sFAAsF;AACtF,qDAAqD;AACrD,OAAO,EAAE,MAAM,0BAA0B,CAAA;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAG3C,MAAM,CAAC,MAAM,YAAY,GAAG,EAAE,CAAC,OAAO,CAAC,+BAA+B,CAAC,CAAA;AACvE,MAAM,CAAC,MAAM,WAAW,GAAG,EAAE,CAAC,OAAO,CAAC,8BAA8B,CAAC,CAAA;AACrE,MAAM,CAAC,MAAM,aAAa,GAAG,EAAE,CAAC,OAAO,CAAC,gCAAgC,CAAC,CAAA;AACzE,MAAM,CAAC,MAAM,iBAAiB,GAAG,EAAE,CAAC,OAAO,CAAC,0CAA0C,CAAC,CAAA;AASvF,iFAAiF;AACjF,MAAM,CAAC,MAAM,GAAG,GAAwB,WAAW,EAAE,CAAA;AAErD,SAAS,WAAW;IAClB,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,iDAAiD,CAAC,CAAA;QAC9F,MAAM,QAAQ,GAAG,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,UAAU,CAAC,CAAA;QACnG,OAAO,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAA;IACpC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAA;IAClB,CAAC;AACH,CAAC"}

package/dist/node-http.d.ts

@@ -0,0 +1,46 @@
+import type { Server } from 'bun';
+/**
+ * A Bun request as dd-trace sees it. This is also the `req` passed to
+ * `tracer.use('http', { server: { hooks: { request } } })`; `request` is the original.
+ */
+export interface NodeRequest {
+    method: string;
+    /** Path and query string, like node:http's `req.url`. */
+    url: string;
+    /** Lower-case header names. */
+    headers: Record<string, string>;
+    socket: {
+        remoteAddress: string | undefined;
+        encrypted: boolean;
+    };
+    request: Request;
+}
+export declare function toNodeRequest(request: Request, server: Server<unknown> | undefined): NodeRequest;
+/**
+ * A Bun response as dd-trace sees it. It holds the status and headers of the Response the
+ * handler returned. dd-trace may add headers to it (CORS allow-headers on preflights) or,
+ * when AppSec blocks a request, replace it with a response of its own.
+ */
+export declare class NodeResponse {
+    #private;
+    readonly req: NodeRequest;
+    statusCode: number;
+    headersSent: boolean;
+    constructor(req: NodeRequest);
+    /** Record the status and headers the handler responded with. */
+    load(response: Response): void;
+    /** True once dd-trace wrote a complete response itself (AppSec blocking). */
+    get ended(): boolean;
+    /** The response dd-trace wrote. */
+    toResponse(): Response;
+    /** The handler's response, with any headers dd-trace added. */
+    withAddedHeaders(response: Response): Response;
+    getHeader(name: string): string | string[] | undefined;
+    getHeaders(): Record<string, string | string[]>;
+    getHeaderNames(): string[];
+    setHeader(name: string, value: string | number | string[]): this;
+    removeHeader(name: string): void;
+    writeHead(statusCode?: number, headers?: Record<string, string>): this;
+    end(body?: string): this;
+}
+//# sourceMappingURL=node-http.d.ts.map

package/dist/node-http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-http.d.ts","sourceRoot":"","sources":["../src/node-http.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,KAAK,CAAA;AAGjC;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,yDAAyD;IACzD,GAAG,EAAE,MAAM,CAAA;IACX,+BAA+B;IAC/B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,MAAM,EAAE;QAAE,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;QAAC,SAAS,EAAE,OAAO,CAAA;KAAE,CAAA;IACjE,OAAO,EAAE,OAAO,CAAA;CACjB;AAED,wBAAgB,aAAa,CAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,GAAG,SAAS,GAAG,WAAW,CAYjG;AAED;;;;GAIG;AACH,qBAAa,YAAY;;IAQV,QAAQ,CAAC,GAAG,EAAE,WAAW;IAPtC,UAAU,SAAM;IAChB,WAAW,UAAQ;gBAMG,GAAG,EAAE,WAAW;IAEtC,gEAAgE;IAChE,IAAI,CAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAO/B,6EAA6E;IAC7E,IAAI,KAAK,IAAK,OAAO,CAEpB;IAED,mCAAmC;IACnC,UAAU,IAAK,QAAQ;IAQvB,+DAA+D;IAC/D,gBAAgB,CAAE,QAAQ,EAAE,QAAQ,GAAG,QAAQ;IAa/C,SAAS,CAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS;IAIvD,UAAU,IAAK,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAIhD,cAAc,IAAK,MAAM,EAAE;IAI3B,SAAS,CAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI;IAOjE,YAAY,CAAE,IAAI,EAAE,MAAM,GAAG,IAAI;IAOjC,SAAS,CAAE,UAAU,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;IAmBvE,GAAG,CAAE,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI;CAM1B"}