// Raw Node.js HTTP server
const http = require('http');
let globalTraceId // 全局变量

// 0. 处理请求的方法
function handleRequest(req, res) {
  // 生成唯一 traceId，每次请求进入，复写 globalTraceId 的值
  globalTraceId = generateTraceId()

  // 检查用户cookie是否有效
  cookieValidator().then((res) => {
    // 校验成功，返回给用户他需要的内容
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.write('Congrats! Your damn cookie is the best one!');
    res.end();
  }).catch((err) => {
    //  把 traceId 连同 error 上报给异常监控系统
    reportError(err, globalTraceId)

    // 写状态码500和错误信息等
    // ...
  });
}

// 1. 创建 server 
const server = http.createServer((req, res) => {
  handleRequest(req, res)
});

// 2. 让 server 和 port:3000 建立 socket 链接，持续接收端口信息
server.listen(3000, () => {
  console.log('Server listening on port 3000');
});

const http = require('http');

function handleRequest(req, res) {
  const traceId = req.headers['x-trace-id'] || generateTraceId();
  // 把 traceId 写入 req 这个 object，将参数一路带下去
  req.traceId = traceId;

  // 同上
  cookieValidator().then((result) => {
    // 校验成功，返回给用户他需要的内容
    // ...
  }).catch((err) => {
    //  上报 traceId
    reportError(err, req.traceId)

    // 写状态码500和错误信息等
    // ...
  });
}

function cookieValidator() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      // do someting
      // ...
    }, 1000);
  });
}

// 此后省略监听等操作
// ...

// Via express
const express = require('express');
const { v4: uuidv4 } = require('uuid');
const { reportError } = require('./error-logging');

const app = express();

// 中间件
app.use((req, res, next) => {
  const traceId = uuidv4(); // generate a new UUID for the trace ID
  req.traceId = traceId; // attach the trace ID to the request object

  next();
});

// 设置路由
app.get('/', async (req, res, next) => {
  const traceId = req.traceId;

  try {
    // call an asynchronous function and pass along the trace ID
    const result = await someAsyncFunction(traceId);

    // do something with the result
    res.send(result);
  } catch (error) {
    // log the error and trace ID to the error logging system
    reportError(error, { traceId });
    next(error);
  }
});

// 监听端口
// ...

const Koa = require('koa');
const { v4: uuidv4 } = require('uuid');
const { reportError } = require('./error-logging');

const app = new Koa();

// 中间件A
app.use(async (ctx, next) => {
  const traceId = uuidv4(); // generate a new UUID for the trace ID
  ctx.state.traceId = traceId; // store the trace ID in the Koa context object

  try {
    await next();
  } catch (error) {
    // log the error and trace ID to the error logging system
    reportError(error, { traceId });
    throw error;
  }
});

// 中间件B，通过 ctx 透传 traceId
app.use(async (ctx) => {
  const traceId = ctx.state.traceId;

  // call an asynchronous function and pass along the trace ID
  const result = await someAsyncFunction(traceId);

  // do something with the result
  ctx.body = result;
});

// 监听端口
// ...

// 使用 nestjs-cls这个库
// npm i nestjs-cls


// 模块初始化的时候，申明 Cls Module
@Module({
  imports: [
    // Register the ClsModule,
    ClsModule.forRoot({
      middleware: {
        // automatically mount the
        // ClsMiddleware for all routes
        mount: true,
        // and use the setup method to
        // provide default store values.
        setup: (cls, req) => {
          // 通过CLS存储 traceId
          cls.set('traceId', req.headers['x-trace-id'] || generateTraceId()); 
        },
      },
    }),
  ],
  providers: [CatService],
  controllers: [CatController],
})
export class AppModule {}


// 在 Service 中注册 Cls，并且直接调用
@Injectable()
export class CatService {
  constructor(
    // We can inject the provided ClsService instance,
    private readonly cls: ClsService,
    private readonly catRepository: CatRepository,
) {}

  getCatForUser() {
    // and use the "get" method to retrieve any stored value.
    const userId = this.cls.get('traceId'); // 获得 traceId
    return this.catRepository.getForUser(userId);
  }
}

// How to use AsyncLocalStorage in Node.js
import http from 'node:http';
import { AsyncLocalStorage } from 'node:async_hooks';

const asyncLocalStorage = new AsyncLocalStorage();

function logWithId(msg) {
  const traceId = asyncLocalStorage.getStore();
  console.log(`${traceId}:`, msg);
}

let traceId = 0;
http.createServer((req, res) => {
  // 关键的API调用
  asyncLocalStorage.run(traceId++, () => {
    logWithId('start');
    // Imagine any chain of async operations here
    setImmediate(() => {
      logWithId('finish');
      res.end();
    });
  });
}).listen(8080);

http.get('http://localhost:8080');
http.get('http://localhost:8080');
// Prints:
//   0: start
//   1: start
//   0: finish
//   1: finish

const express = require('express');
const cls = require('continuation-local-storage'); // require('cls-hooked') 也行，后面会提到
const app = express();

// Create a new namespace for the traceId
const traceNamespace = cls.createNamespace('trace');

// Middleware to set the traceId for each request
app.use((req, res, next) => {
  traceNamespace.run(() => {
    // Generate a new traceId if one doesn't exist
    traceNamespace.set('traceId', generateTraceId());
    next();
  });
});

// Route to get the traceId for the current request
app.get('/traceId', async (req, res) => {
  try {
    const cookie = await cookieValidator()
    // 校验是否成功等
    // ...
  } catch(e) {
    //  上报 traceId
    const traceId = traceNamespace.get('traceId');
    reportError(err, traceId)
  }
  res.send(`Trace ID: ${traceId}`);
});

// load polyfill if native support is unavailable
if (!process.addAsyncListener) require('async-listener');

// createNamespace 就是调用内部的 create 方法
function create(name) {
  assert.ok(name, "namespace must be given a name!");

  var namespace = new Namespace(name); // 新建 space
  namespace.id = process.addAsyncListener({
    create : function () { return namespace.active; },
    before : function (context, storage) { if (storage) namespace.enter(storage); },
    after  : function (context, storage) { if (storage) namespace.exit(storage); },
    error  : function (storage) { if (storage) namespace.exit(storage); }
  });

  process.namespaces[name] = namespace;
  return namespace;
}

// cls的实现

// 这是 store 全局变量的 class
function Namespace(name) {
  this.name   = name;
  // changed in 2.7: no default context
  this.active = null;
  this._set   = [];
  this.id     = null;
}

// run方法
Namespace.prototype.run = function (fn) {
  var context = this.createContext();
  this.enter(context);
  try {
    fn(context);
    return context;
  }
  catch (exception) {
    if (exception) {
      exception[ERROR_SYMBOL] = context;
    }
    throw exception;
  }
  finally {
    this.exit(context);
  }
};

// 当前的 active 入栈，把新的 ctx 当做 this.active
Namespace.prototype.enter = function (context) {
  assert.ok(context, "context must be provided for entering");

  this._set.push(this.active);
  this.active = context;
};

const asyncHooks = require('async-hooks')
const asyncHook = asyncHooks.createHook({
  init: (asyncId, type, triggerAsyncId, resource) => {},
  before: asyncId => {},
  after: asyncId => {},
  destroy: asyncId => {},
  promiseResolve: asyncId => {},
})
asyncHook.enable();



// init() is called during object construction. The resource may not have
// completed construction when this callback runs. Therefore, all fields of the
// resource referenced by "asyncId" may not have been populated.
function init(asyncId, type, triggerAsyncId, resource) { }

// before() is called just before the resource's callback is called. It can be
// called 0-N times for handles (such as TCPWrap), and will be called exactly 1
// time for requests (such as FSReqCallback).
function before(asyncId) { }

// after() is called just after the resource's callback has finished.
function after(asyncId) { }

// destroy() is called when the resource is destroyed.
function destroy(asyncId) { }

class AsyncContext<T> {
  // 快照当前执行上下文中所有 AsyncContext 实例的值，并返回一个函数。
  // 当这个函数执行时，会将 AsyncContext 状态快照恢复为执行上下文的全局状态。
  static wrap<R>(fn: (...args: any[]) => R): (...args: any[]) => R;

  // 立刻执行 fn，并在 fn 执行期间将 value 设置为当前 
  // AsyncContext 实例的值。这个值会在 fn 过程中发起的异步操作中被
  // 快照（相当于 wrap）。
  run<R>(value: T, fn: () => R): R;

  // 获取当前 AsyncContext 实例的值。
  get(): T;
}

class AsyncLocalStorage<T> {
  constructor();

  // 立刻执行 callback，并在 callback 执行期间设置异步局部变量值。
  run<R>(store: T, callback: (...args: any[]) => R, ...args: any[]): R;

  // 获取异步局部变量当前值
  getStore(): T;
}

class AsyncResource {
  // 快照当前的执行上下文异步局部变量全局状态。
  constructor();

  // 立刻执行 fn，并在 fn 执行期间将快照恢复为当前执行上下文异步局部变量全局状态。
  runInAsyncScope<R>(fn: (...args: any[]) => R, thisArg, ...args: any[]): R;
}

public class TraceIdFilter implements Filter {

    private static final String TRACE_ID_HEADER = "X-Trace-Id";

    private static final ThreadLocal<String> TRACE_ID = new ThreadLocal<>();

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        String traceId = httpRequest.getHeader(TRACE_ID_HEADER);
        if (traceId == null || traceId.isEmpty()) {
            traceId = generateTraceId();
        }
        TRACE_ID.set(traceId);
        try {
            chain.doFilter(request, response);
        } finally {
            TRACE_ID.remove();
        }
    }

    public static String getTraceId() {
        return TRACE_ID.get();
    }

    private String generateTraceId() {
        return UUID.randomUUID().toString();
    }

    // Other methods for initializing and destroying the filter...
}

#include <iostream>
#include <thread>

thread_local int my_thread_local;

void my_thread_function() {
    my_thread_local = std::hash<std::thread::id>()(std::this_thread::get_id());
    std::cout << "My thread-local value is " << my_thread_local << std::endl;
}

int main() {
    std::thread t1(my_thread_function);
    std::thread t2(my_thread_function);
    t1.join();
    t2.join();
    return 0;
}

import threading

my_thread_local = threading.local()

def my_thread_function():
    my_thread_local.value = threading.get_ident()
    print(f"My thread-local value is {my_thread_local.value}")

t1 = threading.Thread(target=my_thread_function)
t2 = threading.Thread(target=my_thread_function)
t1.start()
t2.start()
t1.join()
t2.join()