Merge 3ff0b178e0 into 5e9b3712de

Currently only links with no attributes.

cli/tools/lint/rules/mod.rs

@@ -18,6 +18,7 @@ use crate::resolver::CliSloppyImportsResolver;
 
 mod no_sloppy_imports;
 mod no_slow_types;
+mod require_node_prefix;
 
 // used for publishing
 pub use no_slow_types::collect_no_slow_type_diagnostics;
@@ -177,12 +178,17 @@ impl LintRuleProvider {
     maybe_config_file: Option<&ConfigFile>,
   ) -> ConfiguredRules {
     let deno_lint_rules = deno_lint::rules::get_all_rules();
-    let cli_lint_rules = vec![CliLintRule(CliLintRuleKind::Extended(
-      Box::new(no_sloppy_imports::NoSloppyImportsRule::new(
+    let cli_lint_rules = vec![
+      CliLintRule(CliLintRuleKind::Extended(Box::new(
+        no_sloppy_imports::NoSloppyImportsRule::new(
           self.sloppy_imports_resolver.clone(),
           self.workspace_resolver.clone(),
-      )),
-    ))];
+        ),
+      ))),
+      CliLintRule(CliLintRuleKind::Extended(Box::new(
+        require_node_prefix::RequireNodePrefix::new(),
+      ))),
+    ];
     let cli_graph_rules = vec![CliLintRule(CliLintRuleKind::Package(
       Box::new(no_slow_types::NoSlowTypesRule),
     ))];

cli/tools/lint/rules/require_node_prefix.md

@@ -0,0 +1,19 @@
+Enforces the use of the `node:` specifier for Node built-in modules.
+
+Deno requires Node built-in modules to be imported with the `node:` specifier.
+
+### Invalid:
+
+```typescript
+import * as path from "path";
+import * as fs from "fs";
+import * as fsPromises from "fs/promises";
+```
+
+### Valid:
+
+```typescript
+import * as path from "node:path";
+import * as fs from "node:fs";
+import * as fsPromises from "node:fs/promises";
+```

cli/tools/lint/rules/require_node_prefix.rs

@@ -0,0 +1,246 @@
+use std::borrow::Cow;
+
+// Copyright 2020-2021 the Deno authors. All rights reserved. MIT license.
+use super::ExtendedLintRule;
+
+use deno_ast::view as ast_view;
+use deno_ast::SourceRange;
+use deno_ast::SourceRanged;
+use deno_lint::context::Context;
+use deno_lint::diagnostic::LintFix;
+use deno_lint::diagnostic::LintFixChange;
+use deno_lint::rules::LintRule;
+
+#[derive(Debug)]
+pub struct RequireNodePrefix;
+
+const CODE: &str = "require-node-prefix";
+const MESSAGE: &str = "built-in Node modules require the \"node:\" specifier";
+const HINT: &str = "Add \"node:\" prefix in front of the import specifier";
+const FIX_DESC: &str = "Add \"node:\" prefix";
+const DOCS_URL: &str =
+  "https://docs.deno.com/runtime/manual/node/migrate/#node.js-built-ins";
+
+impl ExtendedLintRule for RequireNodePrefix {
+  fn supports_incremental_cache(&self) -> bool {
+    true
+  }
+
+  fn help_docs_url(&self) -> std::borrow::Cow<'static, str> {
+    Cow::Borrowed(DOCS_URL)
+  }
+
+  fn into_base(self: Box<Self>) -> Box<dyn deno_lint::rules::LintRule> {
+    self
+  }
+}
+
+impl LintRule for RequireNodePrefix {
+  fn tags(&self) -> &'static [&'static str] {
+    &["recommended"]
+  }
+
+  fn code(&self) -> &'static str {
+    CODE
+  }
+
+  fn docs(&self) -> &'static str {
+    include_str!("require_node_prefix.md")
+  }
+
+  fn lint_program_with_ast_view<'view>(
+    &self,
+    context: &mut Context<'view>,
+    program: deno_lint::Program<'view>,
+  ) {
+    NodeBuiltinsSpecifierGlobalHandler.traverse(program, context);
+  }
+}
+
+struct NodeBuiltinsSpecifierGlobalHandler;
+
+impl NodeBuiltinsSpecifierGlobalHandler {
+  fn add_diagnostic(&self, ctx: &mut Context, src: &str, range: SourceRange) {
+    let specifier = format!(r#""node:{}""#, src);
+
+    ctx.add_diagnostic_with_fixes(
+      range,
+      CODE,
+      MESSAGE,
+      Some(HINT.to_string()),
+      vec![LintFix {
+        description: FIX_DESC.into(),
+        changes: vec![LintFixChange {
+          new_text: specifier.into(),
+          range,
+        }],
+      }],
+    );
+  }
+}
+
+impl Handler for NodeBuiltinsSpecifierGlobalHandler {
+  fn import_decl(&mut self, decl: &ast_view::ImportDecl, ctx: &mut Context) {
+    let src = decl.src.inner.value.as_str();
+    if is_bare_node_builtin(src) {
+      self.add_diagnostic(ctx, src, decl.src.range());
+    }
+  }
+
+  fn call_expr(&mut self, expr: &ast_view::CallExpr, ctx: &mut Context) {
+    if let ast_view::Callee::Import(_) = expr.callee {
+      if let Some(src_expr) = expr.args.first() {
+        if let ast_view::Expr::Lit(lit) = src_expr.expr {
+          if let ast_view::Lit::Str(str_value) = lit {
+            let src = str_value.inner.value.as_str();
+            if is_bare_node_builtin(src) {
+              self.add_diagnostic(ctx, src, lit.range());
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+// Should match https://nodejs.org/api/module.html#modulebuiltinmodules
+fn is_bare_node_builtin(src: &str) -> bool {
+  matches!(
+    src,
+    "assert"
+      | "assert/strict"
+      | "async_hooks"
+      | "buffer"
+      | "child_process"
+      | "cluster"
+      | "console"
+      | "constants"
+      | "crypto"
+      | "dgram"
+      | "diagnostics_channel"
+      | "dns"
+      | "dns/promises"
+      | "domain"
+      | "events"
+      | "fs"
+      | "fs/promises"
+      | "http"
+      | "http2"
+      | "https"
+      | "inspector"
+      | "inspector/promises"
+      | "module"
+      | "net"
+      | "os"
+      | "path"
+      | "path/posix"
+      | "path/win32"
+      | "perf_hooks"
+      | "process"
+      | "punycode"
+      | "querystring"
+      | "readline"
+      | "readline/promises"
+      | "repl"
+      | "stream"
+      | "stream/consumers"
+      | "stream/promises"
+      | "stream/web"
+      | "string_decoder"
+      | "sys"
+      | "timers"
+      | "timers/promises"
+      | "tls"
+      | "trace_events"
+      | "tty"
+      | "url"
+      | "util"
+      | "util/types"
+      | "v8"
+      | "vm"
+      | "wasi"
+      | "worker_threads"
+      | "zlib"
+  )
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn node_specifier_valid() {
+    assert_lint_ok! {
+      NodeBuiltinsSpecifier,
+      r#"import "node:path";"#,
+      r#"import "node:fs";"#,
+      r#"import "node:fs/promises";"#,
+
+      r#"import * as fs from "node:fs";"#,
+      r#"import * as fsPromises from "node:fs/promises";"#,
+      r#"import fsPromises from "node:fs/promises";"#,
+
+      r#"await import("node:fs");"#,
+      r#"await import("node:fs/promises");"#,
+    };
+  }
+
+  #[test]
+  fn node_specifier_invalid() {
+    assert_lint_err! {
+      NodeBuiltinsSpecifier,
+      MESSAGE,
+      HINT,
+      r#"import "path";"#: [
+        {
+          col: 7,
+          fix: (FIX_DESC, r#"import "node:path";"#),
+        }
+      ],
+      r#"import "fs";"#: [
+        {
+          col: 7,
+          fix: (FIX_DESC, r#"import "node:fs";"#),
+        }
+      ],
+      r#"import "fs/promises";"#: [
+        {
+          col: 7,
+          fix: (FIX_DESC, r#"import "node:fs/promises";"#),
+        }
+      ],
+
+      r#"import * as fs from "fs";"#: [
+        {
+          col: 20,
+          fix: (FIX_DESC, r#"import * as fs from "node:fs";"#),
+        }
+      ],
+      r#"import * as fsPromises from "fs/promises";"#: [
+        {
+          col: 28,
+          fix: (FIX_DESC, r#"import * as fsPromises from "node:fs/promises";"#),
+        }
+      ],
+      r#"import fsPromises from "fs/promises";"#: [
+        {
+          col: 23,
+          fix: (FIX_DESC, r#"import fsPromises from "node:fs/promises";"#),
+        }
+      ],
+
+      r#"await import("fs");"#: [
+        {
+          col: 13,
+          fix: (FIX_DESC, r#"await import("node:fs");"#),
+        }
+      ],
+      r#"await import("fs/promises");"#: [
+        {
+          col: 13,
+          fix: (FIX_DESC, r#"await import("node:fs/promises");"#),
+        }
+      ]
+    };
+  }
+}

ext/node/lib.rs

@@ -226,7 +226,6 @@ deno_core::extension!(deno_node,
     ops::crypto::op_node_decipheriv_decrypt,
     ops::crypto::op_node_decipheriv_final,
     ops::crypto::op_node_decipheriv_set_aad,
-    ops::crypto::op_node_decipheriv_take,
     ops::crypto::op_node_dh_compute_secret,
     ops::crypto::op_node_diffie_hellman,
     ops::crypto::op_node_ecdh_compute_public_key,

ext/node/ops/crypto/cipher.rs

@@ -500,6 +500,11 @@ impl Decipher {
     auth_tag: &[u8],
   ) -> Result<(), DecipherError> {
     use Decipher::*;
+
+    if input.is_empty() && !matches!(self, Aes128Gcm(_) | Aes256Gcm(_)) {
+      return Ok(());
+    }
+
     match (self, auto_pad) {
       (Aes128Cbc(decryptor), true) => {
         assert!(input.len() == 16);

ext/node/ops/crypto/mod.rs

@@ -332,17 +332,6 @@ pub fn op_node_decipheriv_decrypt(
   true
 }
 
-#[op2(fast)]
-pub fn op_node_decipheriv_take(
-  state: &mut OpState,
-  #[smi] rid: u32,
-) -> Result<(), cipher::DecipherContextError> {
-  let context = state.resource_table.take::<cipher::DecipherContext>(rid)?;
-  Rc::try_unwrap(context)
-    .map_err(|_| cipher::DecipherContextError::ContextInUse)?;
-  Ok(())
-}
-
 #[op2]
 pub fn op_node_decipheriv_final(
   state: &mut OpState,

ext/node/polyfills/internal/crypto/cipher.ts

@@ -18,7 +18,6 @@ import {
   op_node_decipheriv_decrypt,
   op_node_decipheriv_final,
   op_node_decipheriv_set_aad,
-  op_node_decipheriv_take,
   op_node_private_decrypt,
   op_node_private_encrypt,
   op_node_public_encrypt,
@@ -352,14 +351,6 @@ export class Decipheriv extends Transform implements Cipher {
   }
 
   final(encoding: string = getDefaultEncoding()): Buffer | string {
-    if (!this.#needsBlockCache || this.#cache.cache.byteLength === 0) {
-      op_node_decipheriv_take(this.#context);
-      return encoding === "buffer" ? Buffer.from([]) : "";
-    }
-    if (this.#cache.cache.byteLength != 16) {
-      throw new Error("Invalid final block size");
-    }
-
     let buf = new Buffer(16);
     op_node_decipheriv_final(
       this.#context,
@@ -369,6 +360,13 @@ export class Decipheriv extends Transform implements Cipher {
       this.#authTag || NO_TAG,
     );
 
+    if (!this.#needsBlockCache || this.#cache.cache.byteLength === 0) {
+      return encoding === "buffer" ? Buffer.from([]) : "";
+    }
+    if (this.#cache.cache.byteLength != 16) {
+      throw new Error("Invalid final block size");
+    }
+
     buf = buf.subarray(0, 16 - buf.at(-1)); // Padded in Pkcs7 mode
     return encoding === "buffer" ? buf : buf.toString(encoding);
   }

ext/os/lib.rs

@@ -116,6 +116,12 @@ deno_core::extension!(
     "op_exit" | "op_set_exit_code" | "op_get_exit_code" =>
       op.with_implementation_from(&deno_core::op_void_sync()),
     _ => op,
+  },
+  state = |state| {
+    #[cfg(unix)]
+    {
+      state.put(ops::signal::SignalState::default());
+    }
   }
 );
 

ext/telemetry/lib.rs

@@ -42,6 +42,7 @@ use opentelemetry::metrics::InstrumentBuilder;
 use opentelemetry::metrics::MeterProvider as _;
 use opentelemetry::otel_debug;
 use opentelemetry::otel_error;
+use opentelemetry::trace::Link;
 use opentelemetry::trace::SpanContext;
 use opentelemetry::trace::SpanId;
 use opentelemetry::trace::SpanKind;
@@ -94,6 +95,7 @@ deno_core::extension!(
     op_otel_span_attribute1,
     op_otel_span_attribute2,
     op_otel_span_attribute3,
+    op_otel_span_add_link,
     op_otel_span_update_name,
     op_otel_metric_attribute3,
     op_otel_metric_record0,
@@ -1324,17 +1326,6 @@ impl OtelSpan {
     }
   }
 
-  #[fast]
-  fn drop_link(&self) {
-    let mut state = self.0.borrow_mut();
-    match &mut **state {
-      OtelSpanState::Recording(span) => {
-        span.links.dropped_count += 1;
-      }
-      OtelSpanState::Done(_) => {}
-    }
-  }
-
   #[fast]
   fn end(&self, end_time: f64) {
     let end_time = if end_time.is_nan() {
@@ -1448,6 +1439,48 @@ fn op_otel_span_update_name<'s>(
   }
 }
 
+#[op2(fast)]
+fn op_otel_span_add_link<'s>(
+  scope: &mut v8::HandleScope<'s>,
+  span: v8::Local<'s, v8::Value>,
+  trace_id: v8::Local<'s, v8::Value>,
+  span_id: v8::Local<'s, v8::Value>,
+  #[smi] trace_flags: u8,
+  is_remote: bool,
+  #[smi] dropped_attributes_count: u32,
+) -> bool {
+  let trace_id = parse_trace_id(scope, trace_id);
+  if trace_id == TraceId::INVALID {
+    return false;
+  };
+  let span_id = parse_span_id(scope, span_id);
+  if span_id == SpanId::INVALID {
+    return false;
+  };
+  let span_context = SpanContext::new(
+    trace_id,
+    span_id,
+    TraceFlags::new(trace_flags),
+    is_remote,
+    TraceState::NONE,
+  );
+
+  let Some(span) =
+    deno_core::_ops::try_unwrap_cppgc_object::<OtelSpan>(scope, span)
+  else {
+    return true;
+  };
+  let mut state = span.0.borrow_mut();
+  if let OtelSpanState::Recording(span) = &mut **state {
+    span.links.links.push(Link::new(
+      span_context,
+      vec![],
+      dropped_attributes_count,
+    ));
+  }
+  true
+}
+
 struct OtelMeter(opentelemetry::metrics::Meter);
 
 impl deno_core::GarbageCollected for OtelMeter {}

ext/telemetry/telemetry.ts

@@ -15,6 +15,7 @@ import {
   op_otel_metric_record2,
   op_otel_metric_record3,
   op_otel_metric_wait_to_observe,
+  op_otel_span_add_link,
   op_otel_span_attribute1,
   op_otel_span_attribute2,
   op_otel_span_attribute3,
@@ -186,7 +187,6 @@ interface OtelSpan {
   spanContext(): SpanContext;
   setStatus(status: SpanStatusCode, errorDescription: string): void;
   dropEvent(): void;
-  dropLink(): void;
   end(endTime: number): void;
 }
 
@@ -359,14 +359,24 @@ class Span {
     return this;
   }
 
-  addLink(_link: Link): Span {
-    this.#otelSpan?.dropLink();
+  addLink(link: Link): Span {
+    const droppedAttributeCount = (link.droppedAttributesCount ?? 0) +
+      (link.attributes ? ObjectKeys(link.attributes).length : 0);
+    const valid = op_otel_span_add_link(
+      this.#otelSpan,
+      link.context.traceId,
+      link.context.spanId,
+      link.context.traceFlags,
+      link.context.isRemote ?? false,
+      droppedAttributeCount,
+    );
+    if (!valid) return this;
     return this;
   }
 
   addLinks(links: Link[]): Span {
     for (let i = 0; i < links.length; i++) {
-      this.#otelSpan?.dropLink();
+      this.addLink(links[i]);
     }
     return this;
   }

tests/specs/cli/otel_basic/__test__.jsonc

@@ -22,6 +22,10 @@
       },
       "args": "run -A main.ts metric.ts",
       "output": "metric.out"
+    },
+    "links": {
+      "args": "run -A main.ts links.ts",
+      "output": "links.out"
     }
   }
 }

tests/specs/cli/otel_basic/links.out

@@ -0,0 +1,96 @@
+{
+  "spans": [
+    {
+      "traceId": "00000000000000000000000000000001",
+      "spanId": "0000000000000001",
+      "traceState": "",
+      "parentSpanId": "",
+      "flags": 1,
+      "name": "example span",
+      "kind": 1,
+      "startTimeUnixNano": "[WILDCARD]",
+      "endTimeUnixNano": "[WILDCARD]",
+      "attributes": [],
+      "droppedAttributesCount": 0,
+      "events": [],
+      "droppedEventsCount": 0,
+      "links": [
+        {
+          "traceId": "1234567890abcdef1234567890abcdef",
+          "spanId": "1234567890abcdef",
+          "traceState": "",
+          "attributes": [],
+          "droppedAttributesCount": 0,
+          "flags": 1
+        }
+      ],
+      "droppedLinksCount": 0,
+      "status": {
+        "message": "",
+        "code": 0
+      }
+    },
+    {
+      "traceId": "00000000000000000000000000000002",
+      "spanId": "0000000000000002",
+      "traceState": "",
+      "parentSpanId": "",
+      "flags": 1,
+      "name": "example span",
+      "kind": 1,
+      "startTimeUnixNano": "[WILDCARD]",
+      "endTimeUnixNano": "[WILDCARD]",
+      "attributes": [],
+      "droppedAttributesCount": 0,
+      "events": [],
+      "droppedEventsCount": 0,
+      "links": [
+        {
+          "traceId": "1234567890abcdef1234567890abcdef",
+          "spanId": "1234567890abcdef",
+          "traceState": "",
+          "attributes": [],
+          "droppedAttributesCount": 0,
+          "flags": 1
+        }
+      ],
+      "droppedLinksCount": 0,
+      "status": {
+        "message": "",
+        "code": 0
+      }
+    },
+    {
+      "traceId": "00000000000000000000000000000003",
+      "spanId": "0000000000000003",
+      "traceState": "",
+      "parentSpanId": "",
+      "flags": 1,
+      "name": "example span",
+      "kind": 1,
+      "startTimeUnixNano": "[WILDCARD]",
+      "endTimeUnixNano": "[WILDCARD]",
+      "attributes": [],
+      "droppedAttributesCount": 0,
+      "events": [],
+      "droppedEventsCount": 0,
+      "links": [
+        {
+          "traceId": "1234567890abcdef1234567890abcdef",
+          "spanId": "1234567890abcdef",
+          "traceState": "",
+          "attributes": [],
+          "droppedAttributesCount": 2,
+          "flags": 1
+        }
+      ],
+      "droppedLinksCount": 0,
+      "status": {
+        "message": "",
+        "code": 0
+      }
+    }
+  ],
+  "logs": [],
+  "metrics": []
+}

tests/specs/cli/otel_basic/links.ts

@@ -0,0 +1,40 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+
+import { trace } from "npm:@opentelemetry/api@1.9.0";
+
+const tracer = trace.getTracer("example-tracer");
+
+const span1 = tracer.startSpan("example span", {
+  links: [{
+    context: {
+      traceId: "1234567890abcdef1234567890abcdef",
+      spanId: "1234567890abcdef",
+      traceFlags: 1,
+    },
+  }],
+});
+span1.end();
+
+const span2 = tracer.startSpan("example span");
+span2.addLink({
+  context: {
+    traceId: "1234567890abcdef1234567890abcdef",
+    spanId: "1234567890abcdef",
+    traceFlags: 1,
+  },
+});
+span2.end();
+
+const span3 = tracer.startSpan("example span");
+span3.addLink({
+  context: {
+    traceId: "1234567890abcdef1234567890abcdef",
+    spanId: "1234567890abcdef",
+    traceFlags: 1,
+  },
+  attributes: {
+    key: "value",
+  },
+  droppedAttributesCount: 1,
+});
+span3.end();

tests/unit_node/crypto/crypto_cipher_gcm_test.ts

@@ -4,7 +4,7 @@ import crypto from "node:crypto";
 import { Buffer } from "node:buffer";
 import testVectors128 from "./gcmEncryptExtIV128.json" with { type: "json" };
 import testVectors256 from "./gcmEncryptExtIV256.json" with { type: "json" };
-import { assertEquals } from "@std/assert";
+import { assertEquals, assertThrows } from "@std/assert";
 
 const aesGcm = (bits: string, key: Uint8Array) => {
   const ALGO = bits == "128" ? `aes-128-gcm` : `aes-256-gcm`;
@@ -123,7 +123,7 @@ Deno.test({
 // Issue #27441
 // https://github.com/denoland/deno/issues/27441
 Deno.test({
-  name: "aes-256-gcm supports IV of non standard length",
+  name: "aes-256-gcm supports IV of non standard length and auth tag check",
   fn() {
     const decipher = crypto.createDecipheriv(
       "aes-256-gcm",
@@ -136,6 +136,10 @@ Deno.test({
       "utf-8",
     );
     assertEquals(decrypted, "this is a secret");
-    decipher.final();
+    assertThrows(
+      () => decipher.final(),
+      TypeError,
+      "Failed to authenticate data",
+    );
   },
 });