docs(learn): Migrate diagnostics user journey from guide to learn section (#6291)

* fix: redirect old guide links to new learn section

- redirect old guide links to new learn section
- fix the focus on click to the #filtering-out-nodejs-internal-functions

* docs(learn): migrate diagnostics user journey to learn

* doc(learn): add redirect changes

* fix(learn): fix redirect url

* doc(learn): move internal links to the nav and fix redirect

* doc(learn): remove toc from files

* docs(learn): change javascript snippets to js

i18n/locales/en.json

···
         "diagnostics": {
           "links": {
             "diagnostics": "Diagnostics",
+            "userJourney": "User Journey",
+            "memory": "Memory",
+            "liveDebugging": "Live Debugging",
+            "poorPerformance": "Poor Performance",
             "flameGraphs": "Flame Graphs"
           }
         }

navigation.json

···
         "diagnostics": {
           "label": "components.navigation.learn.diagnostics.links.diagnostics",
           "items": {
+            "userJourney": {
+              "link": "/learn/diagnostics/user-journey",
+              "label": "components.navigation.learn.diagnostics.links.userJourney"
+            },
+            "memory": {
+              "link": "/learn/diagnostics/memory",
+              "label": "components.navigation.learn.diagnostics.links.memory"
+            },
+            "liveDebugging": {
+              "link": "/learn/diagnostics/live-debugging",
+              "label": "components.navigation.learn.diagnostics.links.liveDebugging"
+            },
+            "poorPerformance": {
+              "link": "/learn/diagnostics/poor-performance",
+              "label": "components.navigation.learn.diagnostics.links.poorPerformance"
+            },
             "flameGraphs": {
               "link": "/learn/diagnostics/flame-graphs",
               "label": "components.navigation.learn.diagnostics.links.flameGraphs"

pages/en/guides/backpressuring-in-streams.md

···
 part of the internal codebase utilizes that module. As a developer, you
 are more than encouraged to use them too!
 
-```javascript
+```js
 const readline = require('readline');
 
 // process.stdin and process.stdout are both instances of Streams.
···
 a script that takes Node.js' module [`zlib`][], that wraps around another
 compression tool, [`gzip(1)`][].
 
-```javascript
+```js
 const gzip = require('zlib').createGzip();
 const fs = require('fs');
 
···
 
 Here is an example of using pipeline:
 
-```javascript
+```js
 const { pipeline } = require('stream');
 const fs = require('fs');
 const zlib = require('zlib');
···
 
 You can also call [`promisify`][] on pipeline to use it with `async` / `await`:
 
-```javascript
+```js
 const stream = require('stream');
 const fs = require('fs');
 const zlib = require('zlib');
···
 occur because the write disk will not be able to keep up with the speed from
 the read.
 
-```javascript
+```js
 // Secretly the stream is saying: "whoa, whoa! hang on, this is way too much!"
 // Data will begin to build up on the read-side of the data buffer as
 // `write` tries to keep up with the incoming data flow.
···
 In this case, your output from your [`Readable`][] stream will enter in the
 [`Transform`][] and will pipe into the [`Writable`][].
 
-```javascript
+```js
 Readable.pipe(Transformable).pipe(Writable);
 ```
 
···
 
 Here is an example of bad practice using [`.push()`][]:
 
-```javascript
+```js
 // This is problematic as it completely ignores return value from push
 // which may be a signal for backpressure from the destination stream!
 class MyReadable extends Readable {
···
 forces data through whenever it is available (signaled by the
 [`'data'` event][]):
 
-```javascript
+```js
 // This ignores the backpressure mechanisms Node.js has set in place,
 // and unconditionally pushes through data, regardless if the
 // destination stream is ready for it or not.
···
 
 Here's an example of using [`.push()`][] with a Readable stream.
 
-```javascript
+```js
 const { Readable } = require('stream');
 
 // Create a custom Readable stream
···
 
 <!-- eslint-disable indent -->
 
-```javascript
+```js
 // This writable is invalid because of the async nature of JavaScript callbacks.
 // Without a return statement for each callback prior to the last,
 // there is a great chance multiple callbacks will be called.
···
 The function is coupled with [`.cork()`][], but there is a common mistake when
 writing:
 
-```javascript
+```js
 // Using .uncork() twice here makes two calls on the C++ layer, rendering the
 // cork/uncork technique useless.
 ws.cork();

pages/en/guides/diagnostics/index.md

···
----
-title: Diagnostics Guide
-layout: docs.hbs
----
-
-# Diagnostics Guide
-
-These guides were created by the [Diagnostics Working Group][] with the
-objective of providing guidance when diagnosing an issue in a user's
-application.
-
-The documentation project is organized based on user journey. Those journeys
-are a coherent set of step-by-step procedures that a user can follow to
-root-cause their issues.
-
-This is the available set of diagnostics guides:
-
-- [Memory](/guides/diagnostics/memory)
-- [Live Debugging](/guides/diagnostics/live-debugging)
-- [Poor Performance](/guides/diagnostics/poor-performance)
-
-[Diagnostics Working Group]: https://github.com/nodejs/diagnostics

pages/en/guides/diagnostics/live-debugging/index.md pages/en/learn/diagnostics/live-debugging/index.md

···
 ---
 title: Live Debugging
-layout: docs.hbs
+layout: learn.hbs
 ---
 
 # Live Debugging
-
-- [Live Debugging](#live-debugging)
-  - [My application doesn’t behave as expected](#my-application-doesnt-behave-as-expected)
-    - [Symptoms](#symptoms)
-    - [Debugging](#debugging)
 
 In this document you can learn about how to live debug a Node.js process.
 
···
 may also want to step through the code and control the execution as well as
 inspect what values variables hold in memory.
 
-- [Using Inspector](/guides/diagnostics/live-debugging/using-inspector)
+- [Using Inspector](/learn/diagnostics/live-debugging/using-inspector)

pages/en/guides/diagnostics/live-debugging/using-inspector.md pages/en/learn/diagnostics/live-debugging/using-inspector.md

···
 ---
 title: Using Inspector
-layout: docs.hbs
+layout: learn.hbs
 ---
 
 # Using Inspector
···
 
 ## How To
 
-/guides/debugging-getting-started/
+[Debugging Node.js](/learn/getting-started/debugging)

pages/en/guides/diagnostics/memory/index.md pages/en/learn/diagnostics/memory/index.md

···
 ---
-title: Memory Diagnostics
-layout: docs.hbs
+title: Memory
+layout: learn.hbs
 ---
 
 # Memory
 
 In this document you can learn about how to debug memory related issues.
-
-- [Memory](#memory)
-  - [My process runs out of memory](#my-process-runs-out-of-memory)
-    - [Symptoms](#symptoms)
-    - [Side Effects](#side-effects)
-  - [My process utilizes memory inefficiently](#my-process-utilizes-memory-inefficiently)
-    - [Symptoms](#symptoms-1)
-    - [Side Effects](#side-effects-1)
-  - [Debugging](#debugging)
 
 ## My process runs out of memory
 
···
 collected. It can also help to know the allocation pattern of our program over
 time.
 
-- [Using Heap Profiler](/guides/diagnostics/memory/using-heap-profiler/)
-- [Using Heap Snapshot](/guides/diagnostics/memory/using-heap-snapshot/)
-- [GC Traces](/guides/diagnostics/memory/using-gc-traces)
+- [Using Heap Profiler](/learn/diagnostics/memory/using-heap-profiler/)
+- [Using Heap Snapshot](/learn/diagnostics/memory/using-heap-snapshot/)
+- [GC Traces](/learn/diagnostics/memory/using-gc-traces)

pages/en/guides/diagnostics/memory/using-gc-traces.md pages/en/learn/diagnostics/memory/using-gc-traces.md

···
 ---
-title: Memory Diagnostics - Using GC Trace
-layout: docs.hbs
+title: Tracing garbage collection
+layout: learn.hbs
 ---
 
 # Tracing garbage collection
···
 [`--max-old-space-size`]: https://nodejs.org/api/cli.html#--max-old-space-sizesize-in-megabytes
 [performance hooks]: https://nodejs.org/api/perf_hooks.html
 [exercise]: https://github.com/nodejs/diagnostics/tree/main/documentation/memory/step3/exercise
-[guide dedicated to heap snapshot]: /guides/diagnostics/memory/using-heap-snapshot#how-to-find-a-memory-leak-with-heap-snapshots
+[guide dedicated to heap snapshot]: /learn/diagnostics/memory/using-heap-snapshot#how-to-find-a-memory-leak-with-heap-snapshots
 [document]: https://github.com/thlorenz/v8-perf/blob/master/gc.md#marking-state
 [Scavenge scenario]: https://github.com/thlorenz/v8-perf/blob/master/gc.md#sample-scavenge-scenario
 [talk of Peter Marshall]: https://v8.dev/blog/trash-talk

pages/en/guides/diagnostics/memory/using-heap-profiler.md pages/en/learn/diagnostics/memory/using-heap-profiler.md

···
 ---
-title: Memory Diagnostics - Using Heap Profiler
-layout: docs.hbs
+title: Using Heap Profiler
+layout: learn.hbs
 ---
 
 # Using Heap Profiler
···
 ## Useful Links
 
 - https://developer.chrome.com/docs/devtools/memory-problems/memory-101/
-- https://github.com/v8/sampling-heap-profiler
 - https://developer.chrome.com/docs/devtools/memory-problems/allocation-profiler/
 
-[Using Heap Snapshot]: /guides/diagnostics/memory/using-heap-snapshot/
+[Using Heap Snapshot]: /learn/diagnostics/memory/using-heap-snapshot/
 [@mmarchini/observe]: https://www.npmjs.com/package/@mmarchini/observe
 [`heap-profiler`]: https://www.npmjs.com/package/heap-profile
 [heap profiler tutorial 1]: /static/images/docs/guides/diagnostics/heap-profiler-tutorial-1.png

pages/en/guides/diagnostics/memory/using-heap-snapshot.md pages/en/learn/diagnostics/memory/using-heap-snapshot.md

···
 ---
-title: Memory Diagnostics - Using Heap Snapshot
-layout: docs.hbs
+title: Using Heap Snapshot
+layout: learn.hbs
 ---
 
 # Using Heap Snapshot

pages/en/guides/diagnostics/poor-performance/index.md pages/en/learn/diagnostics/poor-performance/index.md

···
 ---
-title: Poor Performance - Diagnostics
-layout: docs.hbs
+title: Poor Performance
+layout: learn.hbs
 ---
 
 # Poor Performance
 
 In this document you can learn about how to profile a Node.js process.
-
-- [Poor Performance](#poor-performance)
-  - [My application has a poor performance](#my-application-has-a-poor-performance)
-    - [Symptoms](#symptoms)
-    - [Debugging](#debugging)
 
 ## My application has a poor performance
 
···
 This document provides two simple ways to profile a Node.js application:
 
 - [Using V8 Sampling Profiler](/guides/simple-profiling/)
-- [Using Linux Perf](/guides/diagnostics/poor-performance/using-linux-perf)
+- [Using Linux Perf](/learn/diagnostics/poor-performance/using-linux-perf)

pages/en/guides/diagnostics/poor-performance/using-linux-perf.md pages/en/learn/diagnostics/poor-performance/using-linux-perf.md

···
 ---
-title: Poor Performance - Using Linux Perf
-layout: docs.hbs
+title: Using Linux Perf
+layout: learn.hbs
 ---
 
 # Using Linux Perf

pages/en/guides/dont-block-the-event-loop.md

···
 
 Example 1: A constant-time callback.
 
-```javascript
+```js
 app.get('/constant-time', (req, res) => {
   res.sendStatus(200);
 });
···
 
 Example 2: An `O(n)` callback. This callback will run quickly for small `n` and more slowly for large `n`.
 
-```javascript
+```js
 app.get('/countToN', (req, res) => {
   let n = req.query.n;
 
···
 
 Example 3: An `O(n^2)` callback. This callback will still run quickly for small `n`, but for large `n` it will run much more slowly than the previous `O(n)` example.
 
-```javascript
+```js
 app.get('/countToN2', (req, res) => {
   let n = req.query.n;
 
···
 
 Here is an example vulnerable regexp exposing its server to REDOS:
 
-```javascript
+```js
 app.get('/redos-me', (req, res) => {
   let filePath = req.query.filePath;
 
···
 
 Example: JSON blocking. We create an object `obj` of size 2^21 and `JSON.stringify` it, run `indexOf` on the string, and then JSON.parse it. The `JSON.stringify`'d string is 50MB. It takes 0.7 seconds to stringify the object, 0.03 seconds to indexOf on the 50MB string, and 1.3 seconds to parse the string.
 
-```javascript
+```js
 var obj = { a: 1 };
 var niter = 20;
 
···
 
 Example 1: Un-partitioned average, costs `O(n)`
 
-```javascript
+```js
 for (let i = 0; i < n; i++) sum += i;
 let avg = sum / n;
 console.log('avg: ' + avg);
···
 
 Example 2: Partitioned average, each of the `n` asynchronous steps costs `O(1)`.
 
-```javascript
+```js
 function asyncAvg(n, avgCB) {
   // Save ongoing sum in JS closure.
   var sum = 0;

pages/en/guides/index.md

···
 ## General
 
 - [Easy profiling for Node.js Applications](/guides/simple-profiling/)
-- [Diagnostics - User Journey](/guides/diagnostics/)
 - [Security Best Practices](/guides/security/)
 
 ## Node.js core concepts

pages/en/guides/security/index.md

···
 [Slowloris]: https://en.wikipedia.org/wiki/Slowloris_(computer_security)
 [`http.Server`]: https://nodejs.org/api/http.html#class-httpserver
 [http docs]: https://nodejs.org/api/http.html
-[--inspect switch]: /guides/debugging-getting-started/
+[--inspect switch]: /learn/debugging-getting-started/
 [same-origin policy]: /guides/debugging-getting-started/
 [DNS Rebinding wiki]: https://en.wikipedia.org/wiki/DNS_rebinding
 [files property]: https://docs.npmjs.com/cli/v8/configuring-npm/package-json#files

pages/en/guides/simple-profiling.md

···
 application. Our application will have two handlers, one for adding new users to
 our system:
 
-```javascript
+```js
 app.get('/newUser', (req, res) => {
   let username = req.query.username || '';
   const password = req.query.password || '';
···
 
 and another for validating user authentication attempts:
 
-```javascript
+```js
 app.get('/auth', (req, res) => {
   let username = req.query.username || '';
   const password = req.query.password || '';
···
 To remedy this issue, you make a small modification to the above handlers to use
 the asynchronous version of the pbkdf2 function:
 
-```javascript
+```js
 app.get('/auth', (req, res) => {
   let username = req.query.username || '';
   const password = req.query.password || '';
···
 
 [profiler inside V8]: https://v8.dev/docs/profile
 [benefits of asynchronous programming]: https://nodesource.com/blog/why-asynchronous
-[diagnostics flamegraph]: /guides/diagnostics-flamegraph/
+[diagnostics flamegraph]: /learn/diagnostics/flame-graphs

pages/en/learn/diagnostics/flame-graphs.md

···
    ```
 
 4. Disregard warnings unless they're saying you can't run perf due to missing packages; you may get some warnings about not being able to access kernel module samples which you're not after anyway.
-5. Run `perf script > perfs.out` to generate the data file you'll visualize in a moment. It's useful to [apply some cleanup](#filtering-out-node-js-internal-functions) for a more readable graph
+5. Run `perf script > perfs.out` to generate the data file you'll visualize in a moment. It's useful to [apply some cleanup](#filtering-out-nodejs-internal-functions) for a more readable graph
 6. Install stackvis if not yet installed `npm i -g stackvis`
 7. Run `stackvis perf < perfs.out > flamegraph.htm`
 

pages/en/learn/diagnostics/user-journey.md

···
+---
+title: User Journey
+layout: learn.hbs
+---
+
+# User Journey
+
+These diagnostics guides were created by the [Diagnostics Working Group][] with the
+objective of providing guidance when diagnosing an issue in a user's
+application.
+
+The documentation project is organized based on user journey. Those journeys
+are a coherent set of step-by-step procedures that a user can follow to
+root-cause their issues.
+
+[Diagnostics Working Group]: https://github.com/nodejs/diagnostics

redirects.json

···
       "destination": "https://openjsf.org/certification"
     },
     {
+      "source": "/guides",
+      "destination": "/en/guides"
+    },
+    {
       "source": "/about",
       "destination": "/en/about"
     },
···
     {
       "source": "/:locale/docs/es6",
       "destination": "/:locale/learn/getting-started/ecmascript-2015-es6-and-beyond"
+    },
+    {
+      "source": "/:locale/docs/guides/diagnostics-flamegraph",
+      "destination": "/:locale/learn/diagnostics/flame-graphs"
+    },
+    {
+      "source": "/:locale/docs/guides/diagnostics",
+      "destination": "/:locale/learn/diagnostics/user-journey"
+    },
+    {
+      "source": "/:locale/docs/guides/diagnostics/:path*",
+      "destination": "/:locale/learn/diagnostics/:path*"
     },
     {
       "source": "/:locale/docs",