export function init(options: {
    dsn: string;
    integrations?: Integration[]
}) {
    const monitoring = new Monitoring({
        dsn: options.dsn,
        integrations: options.integrations,
    })

    const transport = new BrowserTransport(options.dsn)
    monitoring.init(transport)
    new Errors(transport).init()  // <mcsymbol name="Errors" filename="index.ts" path="/packages/browser/src/index.ts"startline="11" type="class"></mcsymbol>
    new Metrics(transport).init() // <mcsymbol name="Metrics" filename="index.ts" path="/packages/browser-utils/src/index.ts" startline="21" type="class"></mcsymbol>
}

export interface TTFBMetric extends Metric {
    name: 'TTFB'
    entries: PerformanceNavigationTiming[]
}

export interface TTFBAttribution {
    waitingDuration: number  // 页面加载等待时间
    cacheDuration: number    // 缓存检查时间
    dnsDuration: number      // DNS解析时间
    connectionDuration: number // TCP连接时间
    requestDuration: number  // 请求响应时间
}

export function getBrowserInfo() {
    return {
        userAgent: navigator.userAgent,
        platform: navigator.platform,
        language: navigator.language,
        referrer: document.referrer,
        path: location.pathname
    }
}

interface Integration {
    name: string
    setupOnce: (transport: Transport) => void
}

// 控制台日志集成示例
export const browserTracingIntegration = () => ({
    name: 'browserTracingIntegration',
    setupOnce() {
        captureConsoleIntegration()
    }
})

class BrowserTransport {
    constructor(private dsn: string) {
        // 初始化上报配置
    }

    send(data: any) {
        // 实现逻辑示例:
        navigator.sendBeacon(this.dsn, JSON.stringify(data))
    }
}

export default defineConfig([{
    entry: ['src'],
    format: ['cjs', 'esm'],
    sourcemap: true,
    bundle: true,
    minify: true,
    outDir: 'build'
}])

@Module({
    imports: [
        ConfigModule.forRoot(),
        TypeOrmModule.forRootAsync({/* 数据库配置 */}),
        ClickhouseModule.forRoot({
            url: 'http://localhost:8123',
            username: 'default',
            password: 'heyiclickhouse'
        }),
        AuthModule,
        VersionModule
    ]
})

@Client({
    transport: Transport.KAFKA,
    options: {
        client: { brokers: ['localhost:9094'] },
        consumer: { groupId:'miaoma-consumer' }
    }
})
private kafkaClient: ClientKafka;

async consumeMessages() {
    this.kafkaClient.send('tracking', {}).subscribe({
        next: async message => {
            await this.writeToClickHouse(message.value);
        }
    });
}

@Global()
@Module({})
export class ClickhouseModule {
    static forRoot(options) {
        return {
            providers: [{
                provide: 'CLICKHOUSE_CLIENT',
                useFactory: () => createClient(options)
            }],
            exports: ['CLICKHOUSE_CLIENT']
        }
    }
}

async tracking(params: { event_type: string; message: string }) {
    const res = await this.clickhouseClient.insert({
        table: 'base_monitor_storage',
        values: params,
        format: 'JSONEachRow'
    });
    Logger.log('写入结果', res.summary);
}

async writeToClickHouse(payload: any) {
    try {
        // 写入逻辑
    } catch (error) {
        Logger.error(`写入失败: ${error.message}`, {
            retryCount: 3,
            payloadSize: JSON.stringify(payload).length
        });
        // 实现重试逻辑
    }
}

async batchInsert(records: any[]) {
    await this.clickhouseClient.insert({
        table: 'base_monitor_storage',
        values: records,
        format: 'JSONEachRow'
    });
}

createClient({
    //...
    max_open_connections: 20,
    request_timeout: 30000
});

// 自定义分区器示例
interface PartitionStrategy {
    partitionKey: string; // 项目ID/用户ID/事件类型
    hashAlgorithm:'murmur2' | 'crc32';
}

async sendMessage(topic: string, message: any, strategy: PartitionStrategy) {
    const key = message[strategy.partitionKey];
    const partition = this.calculatePartition(key, strategy);
    await this.kafkaClient.send({
        topic,
        messages: [{
            value: JSON.stringify(message),
            key: key,
            partition
        }]
    });
}

private calculatePartition(key: string, strategy: PartitionStrategy): number {
    const hash = hashFunction(strategy.hashAlgorithm, key);
    return hash % KAFKA_CFG_NUM_PARTITIONS;
}

class MonitoringSDK {
    private endpoint: string;

    constructor(endpoint: string) {
        this.endpoint = endpoint;
        this.init();
    }

    private init() {
        this.collectPerformanceData();
        this.setupErrorHandling();
    }

    private collectPerformanceData() {
        window.addEventListener('load', () => {
            const performanceData = {
                event_type: 'performance',
                timestamp: new Date().toISOString(),
                data: {
                    pageLoadTime: performance.timing.loadEventEnd - performance.timing.navigationStart,
                    fcp: performance.getEntriesByName('first - contentful - paint')[0]?.startTime || null,
                    lcp: performance.getEntriesByType('largest - contentful - paint')[0]?.startTime || null,
                    tti: performance.timing.domInteractive - performance.timing.navigationStart
                }
            };
            this.sendData(performanceData);
        });
    }

    private setupErrorHandling() {
        window.onerror = (message, source, lineno, colno, error) => {
            const errorData = {
                event_type: 'error',
                timestamp: new Date().toISOString(),
                data: {
                    message,
                    source,
                    lineno,
                    colno,
                    stack: error?.stack || ''
                }
            };
            this.sendData(errorData);
        };

        window.addEventListener('unhandledrejection', (event) => {
            const rejectionData = {
                event_type: 'unhandledrejection',
                timestamp: new Date().toISOString(),
                data: {
                    reason: event.reason,
                    stack: event.reason?.stack || ''
                }
            };
            this.sendData(rejectionData);
        });
    }

    private sendData(data: any) {
        navigator.sendBeacon(this.endpoint, JSON.stringify(data));
    }
}

// 使用示例
const monitoring = new MonitoringSDK('https://your - server.com/api/monitoring');

import MonitoringSDK from './monitoring-sdk';
// 初始化SDK
const monitoring = new MonitoringSDK('https://your-server.com/api/monitoring');

import { Controller, Post, Body } from '@nestjs/common';
import { MonitoringService } from './monitoring.service';

@Controller('monitoring')
export class MonitoringController {
    constructor(private readonly monitoringService: MonitoringService) {}

    @Post()
    async receiveData(@Body() data: any) {
        // 将数据传递给服务层处理
        await this.monitoringService.processData(data);
        return { status:'success' };
    }
}

import { Injectable } from '@nestjs/common';
import { Kafka } from 'kafkajs';

@Injectable()
export class MonitoringService {
    private kafkaProducer;

    constructor() {
        const kafka = new Kafka({
            clientId:'monitoring-service',
            brokers: ['kafka:9092']
        });

        this.kafkaProducer = kafka.producer();
        this.kafkaProducer.connect();
    }

    async processData(data: any) {
        // 清洗数据或添加额外信息
        const enrichedData = {
           ...data,
            receivedAt: new Date().toISOString(),
            environment: process.env.NODE_ENV
        };

        // 推送数据到Kafka主题
        await this.kafkaProducer.send({
            topic:'monitoring-events',
            messages: [{ value: JSON.stringify(enrichedData) }]
        });
    }
}

import { Injectable } from '@nestjs/common';
import { Client } from 'clickhouse';

@Injectable()
export class ClickhouseService {
    private client;

    constructor() {
        this.client = new Client({
            url: 'http://clickhouse-server:8123',
            basicAuth: {
                username: 'default',
                password: ''
            },
            debug: false
        });
    }

    async insertData(data: any) {
        const query = `
            INSERT INTO monitoring_data (event_type, timestamp, user_id, session_id, device, url, referrer, element_id, x_position, y_position)
            VALUES?
        `;
        await this.client.insert(query, [data]);
    }

    async queryData() {
        const query = `
            SELECT event_type, COUNT(*) AS event_count
            FROM monitoring_data
            WHERE timestamp >= now() - INTERVAL 1 HOUR
            GROUP BY event_type
            ORDER BY event_count DESC
        `;
        return await this.client.query(query).toPromise();
    }
}

import { Injectable, OnModuleInit } from '@nestjs/common';
import { Kafka } from 'kafkajs';

@Injectable()
export class KafkaConsumerService implements OnModuleInit {
    private kafkaConsumer;

    constructor() {
        const kafka = new Kafka({
            clientId:'monitoring-consumer',
            brokers: ['kafka:9092']
        });

        this.kafkaConsumer = kafka.consumer({ groupId:'monitoring-group' });
    }

    async onModuleInit() {
        await this.kafkaConsumer.connect();
        await this.kafkaConsumer.subscribe({ topic:'monitoring-events', fromBeginning: true });

        this.kafkaConsumer.run({
            eachMessage: async ({ topic, partition, message }) => {
                const eventData = JSON.parse(message.value.toString());
                // 在这里处理数据，例如推送到 ClickHouse 或进行实时分析
                await this.processEventData(eventData);
            }
        });
    }

    async processEventData(data: any) {
        // 在这里进行数据的清洗、聚合等处理
        console.log(`Processing event: ${data.event_type}`);
        // 将数据推送到 ClickHouse
        // this.clickhouseService.insertData(data);
    }
}