์ฝ˜ํ…์ธ  ๋Œ€ํ‘œ ์ด๋ฏธ์ง€ - ๐Ÿš€ ์‘์šฉํ”„๋กœ๊ทธ๋ž˜๋ฐ์—์„œ ์‹ค์‹œ๊ฐ„ ๋ฐ์ดํ„ฐ ์‹œ๊ฐํ™” ๊ตฌํ˜„ํ•˜๊ธฐ - ๋ฐ์ดํ„ฐ๋ฅผ ์‚ด์•„ ์ˆจ์‰ฌ๊ฒŒ ๋งŒ๋“œ๋Š” ๊ธฐ์ˆ 

๐Ÿš€ ์‘์šฉํ”„๋กœ๊ทธ๋ž˜๋ฐ์—์„œ ์‹ค์‹œ๊ฐ„ ๋ฐ์ดํ„ฐ ์‹œ๊ฐํ™” ๊ตฌํ˜„ํ•˜๊ธฐ - ๋ฐ์ดํ„ฐ๋ฅผ ์‚ด์•„ ์ˆจ์‰ฌ๊ฒŒ ๋งŒ๋“œ๋Š” ๊ธฐ์ˆ 

์‹ค์‹œ๊ฐ„์œผ๋กœ ๋ณ€ํ™”ํ•˜๋Š” ๋ฐ์ดํ„ฐ๋ฅผ ๋ˆˆ์•ž์—์„œ ํ™•์ธํ•˜๋Š” ์งœ๋ฆฟํ•จ, ์ง€๊ธˆ ๋ฐ”๋กœ ์‹œ์ž‘ํ•ด๋ณผ๊นŒ์š”? ๐Ÿ’ซ

๐ŸŽฏ ์‹ค์‹œ๊ฐ„ ๋ฐ์ดํ„ฐ ์‹œ๊ฐํ™”, ์™œ ์ด๋ ‡๊ฒŒ ํ•ซํ•œ ๊ฑฐ์•ผ?

์š”์ฆ˜ ๊ฐœ๋ฐœ์ž๋“ค ์‚ฌ์ด์—์„œ ์‹ค์‹œ๊ฐ„ ๋ฐ์ดํ„ฐ ์‹œ๊ฐํ™”๊ฐ€ ์ง„์งœ ๋Œ€์„ธ๋”๋ผ๊ณ ์š” ใ…‹ใ…‹ใ…‹ ์ฃผ์‹ ์ฐจํŠธ ๋ณด๋ฉด์„œ ์‹ค์‹œ๊ฐ„์œผ๋กœ ๋ง‰ ์›€์ง์ด๋Š” ๊ฑฐ ๋ณด๋ฉด ์‹ฌ์žฅ์ด ์ซ„๊นƒํ•ด์ง€์ž–์•„์š”? ๊ทธ๊ฒŒ ๋ฐ”๋กœ ์‹ค์‹œ๊ฐ„ ๋ฐ์ดํ„ฐ ์‹œ๊ฐํ™”์˜ ๋งค๋ ฅ์ด์—์š”! ๐Ÿ“Š

๊ทผ๋ฐ ์ด๊ฒŒ ๋‹จ์ˆœํžˆ ๋ฉ‹์žˆ์–ด ๋ณด์ด๋ ค๊ณ  ํ•˜๋Š” ๊ฒŒ ์•„๋‹ˆ๋ผ, ์‹ค์ œ๋กœ ์—„์ฒญ๋‚œ ๋น„์ฆˆ๋‹ˆ์Šค ๊ฐ€์น˜๋ฅผ ๋งŒ๋“ค์–ด๋‚ด๊ฑฐ๋“ ์š”. ์„œ๋ฒ„ ๋ชจ๋‹ˆํ„ฐ๋ง, ์ฃผ์‹ ๊ฑฐ๋ž˜, IoT ์„ผ์„œ ๋ฐ์ดํ„ฐ, ์†Œ์…œ ๋ฏธ๋””์–ด ํŠธ๋ Œ๋“œ ๋ถ„์„ ๋“ฑ๋“ฑ... ๋ฐ์ดํ„ฐ๊ฐ€ ์‹ค์‹œ๊ฐ„์œผ๋กœ ๋ณ€ํ•˜๋Š” ๋ชจ๋“  ๊ณณ์—์„œ ํ•„์š”ํ•œ ๊ธฐ์ˆ ์ด์—์š”.

๐Ÿ’ก ์‹ค์‹œ๊ฐ„ ์‹œ๊ฐํ™”๊ฐ€ ํ•„์š”ํ•œ ๋Œ€ํ‘œ์ ์ธ ๋ถ„์•ผ๋“ค

โ€ข ๊ธˆ์œต ๊ฑฐ๋ž˜ ์‹œ์Šคํ…œ - ์ฃผ์‹, ์•”ํ˜ธํ™”ํ ์ฐจํŠธ
โ€ข ์„œ๋ฒ„/๋„คํŠธ์›Œํฌ ๋ชจ๋‹ˆํ„ฐ๋ง - CPU, ๋ฉ”๋ชจ๋ฆฌ, ํŠธ๋ž˜ํ”ฝ
โ€ข IoT ๋””๋ฐ”์ด์Šค ๊ด€๋ฆฌ - ์„ผ์„œ ๋ฐ์ดํ„ฐ, ์˜จ๋„, ์Šต๋„
โ€ข ๊ฒŒ์ž„ ๋Œ€์‹œ๋ณด๋“œ - ์‹ค์‹œ๊ฐ„ ํ”Œ๋ ˆ์ด์–ด ํ†ต๊ณ„
โ€ข ์†Œ์…œ ๋ฏธ๋””์–ด ๋ถ„์„ - ํŠธ๋ Œ๋“œ, ๊ฐ์„ฑ ๋ถ„์„
โ€ข ๋ฌผ๋ฅ˜/๋ฐฐ์†ก ์ถ”์  - ์‹ค์‹œ๊ฐ„ ์œ„์น˜ ์ •๋ณด

์‹ค์‹œ๊ฐ„ ๋ฐ์ดํ„ฐ ์‹œ๊ฐํ™” ํŒŒ์ดํ”„๋ผ์ธ ๋ฐ์ดํ„ฐ ์†Œ์Šค ์„ผ์„œ/API/DB ์‹ค์‹œ๊ฐ„ ์ŠคํŠธ๋ฆผ ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ WebSocket SSE/Polling ์‹œ๊ฐํ™” ๋ Œ๋”๋ง Chart.js/D3.js Canvas/SVG ์‚ฌ์šฉ์ž ๋ธŒ๋ผ์šฐ์ € ๋Œ€์‹œ๋ณด๋“œ ์„ฑ๋Šฅ ํ™•์žฅ์„ฑ ์•ˆ์ •์„ฑ ์‚ฌ์šฉ์„ฑ ๋ณด์•ˆ ํ•ต์‹ฌ ๊ณ ๋ ค์‚ฌํ•ญ 5๊ฐ€์ง€ ์‹ค์‹œ๊ฐ„ ์‹œ๊ฐํ™” ๊ตฌํ˜„์‹œ ๋ฐ˜๋“œ์‹œ ์ฒดํฌํ•ด์•ผ ํ•  ์š”์†Œ๋“ค

๐Ÿ”Œ ์‹ค์‹œ๊ฐ„ ํ†ต์‹  ๋ฐฉ์‹ - ์–ด๋–ค ๊ฑธ ์„ ํƒํ• ๊นŒ?

์‹ค์‹œ๊ฐ„ ๋ฐ์ดํ„ฐ๋ฅผ ์ฃผ๊ณ ๋ฐ›๋Š” ๋ฐฉ๋ฒ•์€ ์ƒ๊ฐ๋ณด๋‹ค ๋‹ค์–‘ํ•ด์š”. ๊ฐ๊ฐ ์žฅ๋‹จ์ ์ด ์žˆ์–ด์„œ ์ƒํ™ฉ์— ๋งž๊ฒŒ ๊ณจ๋ผ ์จ์•ผ ํ•˜๋Š”๋ฐ, ์ด๊ฒŒ ์ง„์งœ ์ค‘์š”ํ•˜๊ฑฐ๋“ ์š” ใ…‹ใ…‹ ์ž˜๋ชป ์„ ํƒํ•˜๋ฉด ๋‚˜์ค‘์— ๋ฆฌํŒฉํ† ๋ง ์ง€์˜ฅ์„ ๊ฒฝํ—˜ํ•  ์ˆ˜๋„...

1๏ธโƒฃ WebSocket - ์–‘๋ฐฉํ–ฅ ํ†ต์‹ ์˜ ์™•์ž๋‹˜

WebSocket์€ ์‹ค์‹œ๊ฐ„ ํ†ต์‹ ์˜ ์ ˆ๋Œ€๊ฐ•์ž์˜ˆ์š”. HTTP์™€ ๋‹ฌ๋ฆฌ ํ•œ ๋ฒˆ ์—ฐ๊ฒฐํ•˜๋ฉด ๊ณ„์† ์—ฐ๊ฒฐ ์ƒํƒœ๋ฅผ ์œ ์ง€ํ•˜๋ฉด์„œ ์„œ๋ฒ„์™€ ํด๋ผ์ด์–ธํŠธ๊ฐ€ ์ž์œ ๋กญ๊ฒŒ ๋ฐ์ดํ„ฐ๋ฅผ ์ฃผ๊ณ ๋ฐ›์„ ์ˆ˜ ์žˆ์–ด์š”.

โœจ WebSocket์˜ ์žฅ์ 

โ€ข ๋‚ฎ์€ ๋ ˆ์ดํ„ด์‹œ - ์—ฐ๊ฒฐ ์œ ์ง€๋กœ ์˜ค๋ฒ„ํ—ค๋“œ ์ตœ์†Œํ™”
โ€ข ์–‘๋ฐฉํ–ฅ ํ†ต์‹  - ์„œ๋ฒ„์—์„œ๋„ ํด๋ผ์ด์–ธํŠธ๋กœ ํ‘ธ์‹œ ๊ฐ€๋Šฅ
โ€ข ํšจ์œจ์ ์ธ ๋Œ€์—ญํญ ์‚ฌ์šฉ - ํ—ค๋” ์˜ค๋ฒ„ํ—ค๋“œ๊ฐ€ ์ ์Œ
โ€ข ์‹ค์‹œ๊ฐ„์„ฑ ๋ณด์žฅ - ์ฆ‰๊ฐ์ ์ธ ๋ฐ์ดํ„ฐ ์ „์†ก

๊ธฐ๋ณธ์ ์ธ WebSocket ๊ตฌํ˜„ ์ฝ”๋“œ๋ฅผ ๋ณผ๊นŒ์š”?

// ํด๋ผ์ด์–ธํŠธ ์ธก (JavaScript)
const socket = new WebSocket('ws://localhost:8080/realtime');

socket.onopen = function(event) {
    console.log('WebSocket ์—ฐ๊ฒฐ ์„ฑ๊ณต! ๐ŸŽ‰');
    socket.send(JSON.stringify({ type: 'subscribe', channel: 'stock-data' }));
};

socket.onmessage = function(event) {
    const data = JSON.parse(event.data);
    updateChart(data); // ์ฐจํŠธ ์—…๋ฐ์ดํŠธ ํ•จ์ˆ˜ ํ˜ธ์ถœ
};

socket.onerror = function(error) {
    console.error('WebSocket ์—๋Ÿฌ ๋ฐœ์ƒ:', error);
};

socket.onclose = function(event) {
    console.log('์—ฐ๊ฒฐ ์ข…๋ฃŒ๋จ. ์žฌ์—ฐ๊ฒฐ ์‹œ๋„ ์ค‘...');
    setTimeout(() => reconnect(), 3000);
};
// ์„œ๋ฒ„ ์ธก (Node.js + ws ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ)
const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8080 });

wss.on('connection', function connection(ws) {
    console.log('์ƒˆ๋กœ์šด ํด๋ผ์ด์–ธํŠธ ์—ฐ๊ฒฐ๋จ');
    
    // 1์ดˆ๋งˆ๋‹ค ๋žœ๋ค ๋ฐ์ดํ„ฐ ์ „์†ก
    const interval = setInterval(() => {
        const data = {
            timestamp: Date.now(),
            value: Math.random() * 100,
            symbol: 'AAPL'
        };
        ws.send(JSON.stringify(data));
    }, 1000);
    
    ws.on('close', () => {
        clearInterval(interval);
        console.log('ํด๋ผ์ด์–ธํŠธ ์—ฐ๊ฒฐ ์ข…๋ฃŒ');
    });
});

2๏ธโƒฃ Server-Sent Events (SSE) - ๋‹จ๋ฐฉํ–ฅ์˜ ์‹ฌํ”Œํ•จ

SSE๋Š” ์„œ๋ฒ„์—์„œ ํด๋ผ์ด์–ธํŠธ๋กœ๋งŒ ๋ฐ์ดํ„ฐ๋ฅผ ๋ณด๋‚ด๋Š” ๋‹จ๋ฐฉํ–ฅ ํ†ต์‹ ์ด์—์š”. WebSocket๋ณด๋‹ค ๊ฐ„๋‹จํ•˜์ง€๋งŒ, ์„œ๋ฒ„ ํ‘ธ์‹œ๋งŒ ํ•„์š”ํ•œ ๊ฒฝ์šฐ์—” ์ถฉ๋ถ„ํžˆ ๊ฐ•๋ ฅํ•ด์š”!

๐ŸŽฏ SSE๋ฅผ ์„ ํƒํ•ด์•ผ ํ•˜๋Š” ๊ฒฝ์šฐ

โ€ข ์„œ๋ฒ„์—์„œ ํด๋ผ์ด์–ธํŠธ๋กœ๋งŒ ๋ฐ์ดํ„ฐ ์ „์†ก์ด ํ•„์š”ํ•  ๋•Œ
โ€ข ์ž๋™ ์žฌ์—ฐ๊ฒฐ ๊ธฐ๋Šฅ์ด ํ•„์š”ํ•  ๋•Œ
โ€ข HTTP/2๋ฅผ ํ™œ์šฉํ•˜๊ณ  ์‹ถ์„ ๋•Œ
โ€ข ๊ตฌํ˜„์ด ๊ฐ„๋‹จํ•ด์•ผ ํ•  ๋•Œ

// ํด๋ผ์ด์–ธํŠธ ์ธก
const eventSource = new EventSource('/api/realtime-data');

eventSource.onmessage = function(event) {
    const data = JSON.parse(event.data);
    console.log('์ƒˆ ๋ฐ์ดํ„ฐ ๋„์ฐฉ:', data);
    updateVisualization(data);
};

eventSource.onerror = function(error) {
    console.error('SSE ์—๋Ÿฌ:', error);
    // ์ž๋™์œผ๋กœ ์žฌ์—ฐ๊ฒฐ ์‹œ๋„ํ•จ
};
// ์„œ๋ฒ„ ์ธก (Express.js)
app.get('/api/realtime-data', (req, res) => {
    res.setHeader('Content-Type', 'text/event-stream');
    res.setHeader('Cache-Control', 'no-cache');
    res.setHeader('Connection', 'keep-alive');
    
    const sendData = () => {
        const data = {
            timestamp: Date.now(),
            temperature: 20 + Math.random() * 10,
            humidity: 40 + Math.random() * 20
        };
        res.write(`data: ${JSON.stringify(data)}\n\n`);
    };
    
    const interval = setInterval(sendData, 2000);
    
    req.on('close', () => {
        clearInterval(interval);
    });
});

3๏ธโƒฃ Long Polling - ๊ตฌ์‹์ด์ง€๋งŒ ํ˜ธํ™˜์„ฑ ๊ฐ‘

Long Polling์€ ์ข€ ์˜›๋‚  ๋ฐฉ์‹์ด๊ธด ํ•œ๋ฐ, ๋ ˆ๊ฑฐ์‹œ ๋ธŒ๋ผ์šฐ์ € ์ง€์›์ด ํ•„์š”ํ•˜๊ฑฐ๋‚˜ ๋ฐฉํ™”๋ฒฝ ์ด์Šˆ๊ฐ€ ์žˆ์„ ๋•Œ ์œ ์šฉํ•ด์š” ใ…Žใ…Ž

// ํด๋ผ์ด์–ธํŠธ ์ธก Long Polling
function longPoll() {
    fetch('/api/poll-data')
        .then(response => response.json())
        .then(data => {
            updateChart(data);
            longPoll(); // ์ฆ‰์‹œ ๋‹ค์Œ ์š”์ฒญ
        })
        .catch(error => {
            console.error('Polling ์—๋Ÿฌ:', error);
            setTimeout(longPoll, 5000); // ์—๋Ÿฌ ์‹œ 5์ดˆ ํ›„ ์žฌ์‹œ๋„
        });
}

longPoll(); // ์‹œ์ž‘
ํ†ต์‹  ๋ฐฉ์‹ ์žฅ์  ๋‹จ์  ์ ํ•ฉํ•œ ์ƒํ™ฉ
WebSocket ์–‘๋ฐฉํ–ฅ, ๋‚ฎ์€ ์ง€์—ฐ, ํšจ์œจ์  ๊ตฌํ˜„ ๋ณต์žก๋„, ํ”„๋ก์‹œ ์ด์Šˆ ์ฑ„ํŒ…, ๊ฒŒ์ž„, ์‹ค์‹œ๊ฐ„ ํ˜‘์—…
SSE ๊ฐ„๋‹จํ•œ ๊ตฌํ˜„, ์ž๋™ ์žฌ์—ฐ๊ฒฐ ๋‹จ๋ฐฉํ–ฅ, IE ๋ฏธ์ง€์› ์•Œ๋ฆผ, ํ”ผ๋“œ, ๋ชจ๋‹ˆํ„ฐ๋ง
Long Polling ๋†’์€ ํ˜ธํ™˜์„ฑ, ๋ฐฉํ™”๋ฒฝ ํ†ต๊ณผ ๋†’์€ ์˜ค๋ฒ„ํ—ค๋“œ, ๋น„ํšจ์œจ์  ๋ ˆ๊ฑฐ์‹œ ์ง€์› ํ•„์š”์‹œ
Short Polling ๊ตฌํ˜„ ๋งค์šฐ ๊ฐ„๋‹จ ๋งค์šฐ ๋น„ํšจ์œจ์ , ์„œ๋ฒ„ ๋ถ€ํ•˜ ์‹ค์‹œ๊ฐ„์„ฑ ๋‚ฎ์•„๋„ ๋  ๋•Œ

๐Ÿ“Š ์‹œ๊ฐํ™” ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ ์„ ํƒ ๊ฐ€์ด๋“œ

์‹ค์‹œ๊ฐ„ ๋ฐ์ดํ„ฐ๋ฅผ ๋ฐ›์•˜์œผ๋ฉด ์ด์ œ ์˜ˆ์˜๊ฒŒ ๋ณด์—ฌ์ค˜์•ผ๊ฒ ์ฃ ? ์‹œ๊ฐํ™” ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ ์„ ํƒ์ด ์ง„์งœ ์ค‘์š”ํ•œ๋ฐ, ๊ฐ์ž ํŠน์ง•์ด ํ™•์‹คํ•ด์„œ ์šฉ๋„์— ๋งž๊ฒŒ ๊ณจ๋ผ์•ผ ํ•ด์š” ใ…‹ใ…‹ใ…‹

๐ŸŽจ Chart.js - ์ž…๋ฌธ์ž์˜ ๋ฒ ํ”„

Chart.js๋Š” ์ •๋ง ์‰ฝ๊ณ  ์ง๊ด€์ ์ด์—์š”. ๋ฌธ์„œ๋„ ์ž˜ ๋˜์–ด ์žˆ๊ณ , ์ปค๋ฎค๋‹ˆํ‹ฐ๋„ ํ™œ๋ฐœํ•ด์„œ ์ฒ˜์Œ ์‹œ์ž‘ํ•˜๊ธฐ ๋”ฑ ์ข‹์•„์š”. ์‹ค์‹œ๊ฐ„ ์—…๋ฐ์ดํŠธ๋„ ๊ฐ„๋‹จํ•˜๊ฒŒ ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ์–ด์š”!

// Chart.js๋กœ ์‹ค์‹œ๊ฐ„ ์ฐจํŠธ ๋งŒ๋“ค๊ธฐ
const ctx = document.getElementById('myChart').getContext('2d');
const chart = new Chart(ctx, {
    type: 'line',
    data: {
        labels: [],
        datasets: [{
            label: '์‹ค์‹œ๊ฐ„ ์˜จ๋„',
            data: [],
            borderColor: 'rgb(102, 126, 234)',
            backgroundColor: 'rgba(102, 126, 234, 0.1)',
            tension: 0.4
        }]
    },
    options: {
        responsive: true,
        animation: {
            duration: 750 // ๋ถ€๋“œ๋Ÿฌ์šด ์• ๋‹ˆ๋ฉ”์ด์…˜
        },
        scales: {
            y: {
                beginAtZero: true
            }
        }
    }
});

// ์‹ค์‹œ๊ฐ„ ๋ฐ์ดํ„ฐ ์ถ”๊ฐ€ ํ•จ์ˆ˜
function addData(label, data) {
    chart.data.labels.push(label);
    chart.data.datasets[0].data.push(data);
    
    // ์ตœ๋Œ€ 20๊ฐœ ๋ฐ์ดํ„ฐ๋งŒ ์œ ์ง€
    if (chart.data.labels.length > 20) {
        chart.data.labels.shift();
        chart.data.datasets[0].data.shift();
    }
    
    chart.update('none'); // ์• ๋‹ˆ๋ฉ”์ด์…˜ ์—†์ด ์ฆ‰์‹œ ์—…๋ฐ์ดํŠธ
}

// WebSocket์œผ๋กœ ๋ฐ›์€ ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ
socket.onmessage = function(event) {
    const data = JSON.parse(event.data);
    const time = new Date(data.timestamp).toLocaleTimeString();
    addData(time, data.temperature);
};

๐Ÿ’ก Chart.js ์‹ค์‹œ๊ฐ„ ์ตœ์ ํ™” ํŒ

โ€ข update('none') ์‚ฌ์šฉ์œผ๋กœ ์• ๋‹ˆ๋ฉ”์ด์…˜ ์Šคํ‚ต
โ€ข ๋ฐ์ดํ„ฐ ํฌ์ธํŠธ ๊ฐœ์ˆ˜ ์ œํ•œ (20~50๊ฐœ ๊ถŒ์žฅ)
โ€ข decimation ํ”Œ๋Ÿฌ๊ทธ์ธ์œผ๋กœ ๋ฐ์ดํ„ฐ ๊ฐ„์†Œํ™”
โ€ข responsive: true๋กœ ๋ฐ˜์‘ํ˜• ๋Œ€์‘

๐Ÿš€ D3.js - ์ปค์Šคํ„ฐ๋งˆ์ด์ง•์˜ ์‹ 

D3.js๋Š” ์ง„์งœ ์ž์œ ๋„๊ฐ€ ๋†’์•„์š”. ์›ํ•˜๋Š” ๋Œ€๋กœ ๋ญ๋“ ์ง€ ๋งŒ๋“ค ์ˆ˜ ์žˆ๋Š”๋ฐ, ๊ทธ๋งŒํผ ๋Ÿฌ๋‹์ปค๋ธŒ๊ฐ€ ์žˆ์ฃ  ใ… ใ…  ํ•˜์ง€๋งŒ ๋ณต์žกํ•œ ์ธํ„ฐ๋ž™์…˜์ด๋‚˜ ๋…ํŠนํ•œ ์‹œ๊ฐํ™”๊ฐ€ ํ•„์š”ํ•˜๋ฉด D3๊ฐ€ ๋‹ต์ด์—์š”!

// D3.js๋กœ ์‹ค์‹œ๊ฐ„ ๋ผ์ธ ์ฐจํŠธ
const margin = {top: 20, right: 30, bottom: 30, left: 40};
const width = 800 - margin.left - margin.right;
const height = 400 - margin.top - margin.bottom;

const svg = d3.select("#chart")
    .append("svg")
    .attr("width", width + margin.left + margin.right)
    .attr("height", height + margin.top + margin.bottom)
    .append("g")
    .attr("transform", `translate(${margin.left},${margin.top})`);

let data = [];
const maxDataPoints = 50;

// ์Šค์ผ€์ผ ์„ค์ •
const x = d3.scaleTime().range([0, width]);
const y = d3.scaleLinear().range([height, 0]);

// ๋ผ์ธ ์ƒ์„ฑ๊ธฐ
const line = d3.line()
    .x(d => x(d.time))
    .y(d => y(d.value))
    .curve(d3.curveMonotoneX);

// ์ถ• ์ถ”๊ฐ€
const xAxis = svg.append("g")
    .attr("transform", `translate(0,${height})`);
const yAxis = svg.append("g");

// ๋ผ์ธ ํŒจ์Šค
const path = svg.append("path")
    .attr("fill", "none")
    .attr("stroke", "#667eea")
    .attr("stroke-width", 2);

// ์‹ค์‹œ๊ฐ„ ์—…๋ฐ์ดํŠธ ํ•จ์ˆ˜
function updateChart(newValue) {
    data.push({
        time: new Date(),
        value: newValue
    });
    
    if (data.length > maxDataPoints) {
        data.shift();
    }
    
    // ์Šค์ผ€์ผ ์—…๋ฐ์ดํŠธ
    x.domain(d3.extent(data, d => d.time));
    y.domain([0, d3.max(data, d => d.value)]);
    
    // ์ถ• ์—…๋ฐ์ดํŠธ
    xAxis.transition().duration(500).call(d3.axisBottom(x));
    yAxis.transition().duration(500).call(d3.axisLeft(y));
    
    // ๋ผ์ธ ์—…๋ฐ์ดํŠธ
    path.datum(data)
        .transition()
        .duration(500)
        .attr("d", line);
}

โšก Apache ECharts - ์„ฑ๋Šฅ ๊ดด๋ฌผ

ECharts๋Š” ์ค‘๊ตญ์—์„œ ๋งŒ๋“  ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ์ธ๋ฐ, ์„ฑ๋Šฅ์ด ์ง„์งœ ๋ฏธ์ณค์–ด์š” ใ…‹ใ…‹ใ…‹ ๋Œ€์šฉ๋Ÿ‰ ๋ฐ์ดํ„ฐ๋„ ๊ฑฐ๋œฌํ•˜๊ณ , ์ฐจํŠธ ์ข…๋ฅ˜๋„ ์—„์ฒญ ๋งŽ์•„์š”. ์ตœ๊ทผ์— ์ธ๊ธฐ ๊ธ‰์ƒ์Šน ์ค‘!

// ECharts ์‹ค์‹œ๊ฐ„ ์ฐจํŠธ
const myChart = echarts.init(document.getElementById('main'));

const option = {
    title: {
        text: '์‹ค์‹œ๊ฐ„ ์„œ๋ฒ„ ๋ชจ๋‹ˆํ„ฐ๋ง'
    },
    tooltip: {
        trigger: 'axis'
    },
    xAxis: {
        type: 'category',
        data: []
    },
    yAxis: {
        type: 'value',
        name: 'CPU ์‚ฌ์šฉ๋ฅ  (%)'
    },
    series: [{
        name: 'CPU',
        type: 'line',
        smooth: true,
        data: [],
        areaStyle: {
            color: new echarts.graphic.LinearGradient(0, 0, 0, 1, [{
                offset: 0,
                color: 'rgba(102, 126, 234, 0.5)'
            }, {
                offset: 1,
                color: 'rgba(102, 126, 234, 0.1)'
            }])
        }
    }]
};

myChart.setOption(option);

// ์‹ค์‹œ๊ฐ„ ๋ฐ์ดํ„ฐ ์ถ”๊ฐ€
function addRealtimeData(timestamp, value) {
    option.xAxis.data.push(timestamp);
    option.series[0].data.push(value);
    
    // ์ตœ๋Œ€ 30๊ฐœ ์œ ์ง€
    if (option.xAxis.data.length > 30) {
        option.xAxis.data.shift();
        option.series[0].data.shift();
    }
    
    myChart.setOption(option);
}
๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ ๋‚œ์ด๋„ ์„ฑ๋Šฅ ์ปค์Šคํ„ฐ๋งˆ์ด์ง• ์ถ”์ฒœ ์šฉ๋„
Chart.js โญ ์‰ฌ์›€ โญโญโญ ๋ณดํ†ต โญโญ ์ œํ•œ์  ๊ฐ„๋‹จํ•œ ๋Œ€์‹œ๋ณด๋“œ, ํ”„๋กœํ† ํƒ€์ž…
D3.js โญโญโญโญโญ ์–ด๋ ค์›€ โญโญโญโญ ์ข‹์Œ โญโญโญโญโญ ๋ฌดํ•œ ๋ณต์žกํ•œ ์ธํ„ฐ๋ž™์…˜, ๋…ํŠนํ•œ ์‹œ๊ฐํ™”
ECharts โญโญ ๋ณดํ†ต โญโญโญโญโญ ์ตœ๊ณ  โญโญโญโญ ๋†’์Œ ๋Œ€์šฉ๋Ÿ‰ ๋ฐ์ดํ„ฐ, ์—”ํ„ฐํ”„๋ผ์ด์ฆˆ
Plotly.js โญโญ ๋ณดํ†ต โญโญโญ ๋ณดํ†ต โญโญโญ ๋ณดํ†ต ๊ณผํ•™/ํ†ต๊ณ„ ์‹œ๊ฐํ™”
Highcharts โญโญ ๋ณดํ†ต โญโญโญโญ ์ข‹์Œ โญโญโญ ๋ณดํ†ต ์ƒ์—…์šฉ ํ”„๋กœ์ ํŠธ (์œ ๋ฃŒ)

โš™๏ธ ์„ฑ๋Šฅ ์ตœ์ ํ™” - ๋Š๊น€ ์—†๋Š” ์‹ค์‹œ๊ฐ„ ๊ฒฝํ—˜ ๋งŒ๋“ค๊ธฐ

์‹ค์‹œ๊ฐ„ ์‹œ๊ฐํ™”์—์„œ ์„ฑ๋Šฅ์€ ์ง„์งœ ์ƒ๋ช…์ด์—์š”! ๋ฐ์ดํ„ฐ๊ฐ€ ๋ง‰ ์Ÿ์•„์ง€๋Š”๋ฐ ํ™”๋ฉด์ด ๋ฒ„๋ฒ…๊ฑฐ๋ฆฌ๋ฉด... ์‚ฌ์šฉ์ž๋“ค์ด ๋ฐ”๋กœ ์ดํƒˆํ•˜๊ฑฐ๋“ ์š” ใ… ใ…  ์„ฑ๋Šฅ ์ตœ์ ํ™” ๊ฟ€ํŒ๋“ค์„ ๊ณต์œ ํ• ๊ฒŒ์š”!

๐ŸŽฏ ๋ฐ์ดํ„ฐ ์ƒ˜ํ”Œ๋ง๊ณผ ์ง‘๊ณ„

์ดˆ๋‹น 100๊ฐœ์”ฉ ๋ฐ์ดํ„ฐ๊ฐ€ ๋“ค์–ด์˜ค๋Š”๋ฐ ์ „๋ถ€ ๋‹ค ๊ทธ๋ฆด ํ•„์š”๋Š” ์—†์ž–์•„์š”? ์ ์ ˆํ•œ ์ƒ˜ํ”Œ๋ง์ด ํ•ต์‹ฌ์ด์—์š”!

// ๋ฐ์ดํ„ฐ ์ƒ˜ํ”Œ๋ง ํด๋ž˜์Šค
class DataSampler {
    constructor(maxPoints = 50) {
        this.maxPoints = maxPoints;
        this.buffer = [];
        this.lastUpdate = Date.now();
        this.updateInterval = 100; // 100ms๋งˆ๋‹ค ์—…๋ฐ์ดํŠธ
    }
    
    addData(value) {
        this.buffer.push({
            timestamp: Date.now(),
            value: value
        });
        
        // ๋ฒ„ํผ๊ฐ€ ๋„ˆ๋ฌด ํฌ๋ฉด ์˜ค๋ž˜๋œ ๋ฐ์ดํ„ฐ ์ œ๊ฑฐ
        if (this.buffer.length > this.maxPoints * 2) {
            this.buffer = this.buffer.slice(-this.maxPoints);
        }
    }
    
    getSampledData() {
        const now = Date.now();
        if (now - this.lastUpdate < this.updateInterval) {
            return null; // ์•„์ง ์—…๋ฐ์ดํŠธ ์‹œ๊ฐ„ ์•„๋‹˜
        }
        
        this.lastUpdate = now;
        
        if (this.buffer.length <= this.maxPoints) {
            return this.buffer;
        }
        
        // ๊ท ๋“ฑ ์ƒ˜ํ”Œ๋ง
        const step = this.buffer.length / this.maxPoints;
        const sampled = [];
        for (let i = 0; i < this.maxPoints; i++) {
            const index = Math.floor(i * step);
            sampled.push(this.buffer[index]);
        }
        
        return sampled;
    }
    
    // ์‹œ๊ฐ„ ๊ธฐ๋ฐ˜ ์ง‘๊ณ„ (1์ดˆ ๋‹จ์œ„ ํ‰๊ท )
    getAggregatedData(intervalMs = 1000) {
        const aggregated = [];
        const buckets = new Map();
        
        this.buffer.forEach(item => {
            const bucketKey = Math.floor(item.timestamp / intervalMs) * intervalMs;
            if (!buckets.has(bucketKey)) {
                buckets.set(bucketKey, []);
            }
            buckets.get(bucketKey).push(item.value);
        });
        
        buckets.forEach((values, timestamp) => {
            const avg = values.reduce((a, b) => a + b, 0) / values.length;
            aggregated.push({ timestamp, value: avg });
        });
        
        return aggregated;
    }
}

// ์‚ฌ์šฉ ์˜ˆ์‹œ
const sampler = new DataSampler(50);

socket.onmessage = function(event) {
    const data = JSON.parse(event.data);
    sampler.addData(data.value);
};

// ์ฃผ๊ธฐ์ ์œผ๋กœ ์ฐจํŠธ ์—…๋ฐ์ดํŠธ
setInterval(() => {
    const sampledData = sampler.getSampledData();
    if (sampledData) {
        updateChart(sampledData);
    }
}, 100);

๐Ÿš€ requestAnimationFrame ํ™œ์šฉ

๋ธŒ๋ผ์šฐ์ €์˜ ๋ฆฌํŽ˜์ธํŠธ ์ฃผ๊ธฐ์— ๋งž์ถฐ์„œ ์—…๋ฐ์ดํŠธํ•˜๋ฉด ํ›จ์”ฌ ๋ถ€๋“œ๋Ÿฌ์›Œ์š”! requestAnimationFrame์„ ํ™œ์šฉํ•˜๋ฉด 60fps๋กœ ๋งค๋„๋Ÿฝ๊ฒŒ ๋ Œ๋”๋งํ•  ์ˆ˜ ์žˆ์–ด์š”.

// RAF๋ฅผ ํ™œ์šฉํ•œ ๋ถ€๋“œ๋Ÿฌ์šด ์• ๋‹ˆ๋ฉ”์ด์…˜
class SmoothChart {
    constructor(canvas) {
        this.canvas = canvas;
        this.ctx = canvas.getContext('2d');
        this.dataQueue = [];
        this.currentData = [];
        this.isAnimating = false;
        this.maxPoints = 100;
    }
    
    addData(value) {
        this.dataQueue.push(value);
        if (!this.isAnimating) {
            this.startAnimation();
        }
    }
    
    startAnimation() {
        this.isAnimating = true;
        this.animate();
    }
    
    animate() {
        // ํ์—์„œ ๋ฐ์ดํ„ฐ ๊ฐ€์ ธ์˜ค๊ธฐ
        while (this.dataQueue.length > 0) {
            this.currentData.push(this.dataQueue.shift());
            if (this.currentData.length > this.maxPoints) {
                this.currentData.shift();
            }
        }
        
        // ์บ”๋ฒ„์Šค ํด๋ฆฌ์–ด
        this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
        
        // ์ฐจํŠธ ๊ทธ๋ฆฌ๊ธฐ
        this.drawChart();
        
        // ๋‹ค์Œ ํ”„๋ ˆ์ž„ ์˜ˆ์•ฝ
        if (this.dataQueue.length > 0 || this.isAnimating) {
            requestAnimationFrame(() => this.animate());
        } else {
            this.isAnimating = false;
        }
    }
    
    drawChart() {
        const width = this.canvas.width;
        const height = this.canvas.height;
        const step = width / this.maxPoints;
        
        this.ctx.beginPath();
        this.ctx.strokeStyle = '#667eea';
        this.ctx.lineWidth = 2;
        
        this.currentData.forEach((value, index) => {
            const x = index * step;
            const y = height - (value / 100) * height;
            
            if (index === 0) {
                this.ctx.moveTo(x, y);
            } else {
                this.ctx.lineTo(x, y);
            }
        });
        
        this.ctx.stroke();
    }
}

๐Ÿ’พ Web Workers๋กœ ๋ฐฑ๊ทธ๋ผ์šด๋“œ ์ฒ˜๋ฆฌ

๋ฌด๊ฑฐ์šด ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ๋Š” Web Worker๋กœ ๋ถ„๋ฆฌํ•˜๋ฉด ๋ฉ”์ธ ์Šค๋ ˆ๋“œ๊ฐ€ ์•ˆ ๋ง‰ํ˜€์š”! UI๋Š” ๊ณ„์† ๋ถ€๋“œ๋Ÿฝ๊ฒŒ ์œ ์ง€๋˜๊ณ ์š” ใ…Žใ…Ž

// worker.js - Web Worker ํŒŒ์ผ
self.onmessage = function(e) {
    const { type, data } = e.data;
    
    if (type === 'process') {
        // ๋ณต์žกํ•œ ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ
        const processed = processLargeDataset(data);
        self.postMessage({ type: 'result', data: processed });
    }
};

function processLargeDataset(rawData) {
    // ํ†ต๊ณ„ ๊ณ„์‚ฐ, ํ•„ํ„ฐ๋ง, ๋ณ€ํ™˜ ๋“ฑ
    const result = {
        average: calculateAverage(rawData),
        trend: calculateTrend(rawData),
        anomalies: detectAnomalies(rawData)
    };
    return result;
}

function calculateAverage(data) {
    return data.reduce((sum, val) => sum + val, 0) / data.length;
}

function calculateTrend(data) {
    // ๊ฐ„๋‹จํ•œ ์„ ํ˜• ํšŒ๊ท€
    const n = data.length;
    let sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0;
    
    data.forEach((y, x) => {
        sumX += x;
        sumY += y;
        sumXY += x * y;
        sumX2 += x * x;
    });
    
    const slope = (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX);
    return slope > 0 ? 'increasing' : 'decreasing';
}

function detectAnomalies(data) {
    const mean = calculateAverage(data);
    const stdDev = Math.sqrt(
        data.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / data.length
    );
    
    return data.filter(val => Math.abs(val - mean) > 2 * stdDev);
}
// ๋ฉ”์ธ ์Šค๋ ˆ๋“œ์—์„œ Worker ์‚ฌ์šฉ
const worker = new Worker('worker.js');

worker.onmessage = function(e) {
    const { type, data } = e.data;
    if (type === 'result') {
        updateChartWithProcessedData(data);
    }
};

// ๋Œ€์šฉ๋Ÿ‰ ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ ์š”์ฒญ
socket.onmessage = function(event) {
    const rawData = JSON.parse(event.data);
    worker.postMessage({ type: 'process', data: rawData });
};

โš ๏ธ ์„ฑ๋Šฅ ์ตœ์ ํ™” ์ฃผ์˜์‚ฌํ•ญ

โ€ข ๊ณผ๋„ํ•œ ์ตœ์ ํ™”๋Š” ์ฝ”๋“œ ๋ณต์žก๋„๋ฅผ ๋†’์—ฌ์š” - ํ•„์š”ํ•œ ๋งŒํผ๋งŒ!
โ€ข ๋ฉ”๋ชจ๋ฆฌ ๋ˆ„์ˆ˜ ์กฐ์‹ฌ - ์ด๋ฒคํŠธ ๋ฆฌ์Šค๋„ˆ ์ •๋ฆฌ ํ•„์ˆ˜
โ€ข ๋ชจ๋ฐ”์ผ ํ™˜๊ฒฝ ๊ณ ๋ ค - ๋ฐ์Šคํฌํ†ฑ๋ณด๋‹ค ์„ฑ๋Šฅ ์ œ์•ฝ ํผ
โ€ข ํ”„๋กœํŒŒ์ผ๋ง ๋จผ์ € - ์ถ”์ธกํ•˜์ง€ ๋ง๊ณ  ์ธก์ •ํ•˜์„ธ์š”!

์„ฑ๋Šฅ ์ตœ์ ํ™” ์ฒดํฌ๋ฆฌ์ŠคํŠธ ํ”„๋ก ํŠธ์—”๋“œ ์ตœ์ ํ™” ๋ฐ์ดํ„ฐ ์ƒ˜ํ”Œ๋ง ์ ์šฉ RAF ํ™œ์šฉํ•œ ๋ Œ๋”๋ง Web Worker ๋ถ„๋ฆฌ Canvas ์ตœ์ ํ™” ๋ฉ”๋ชจ๋ฆฌ ๊ด€๋ฆฌ ์ด๋ฒคํŠธ ์“ฐ๋กœํ‹€๋ง ๋ ˆ์ด์ง€ ๋กœ๋”ฉ ๋ฒˆ๋“ค ์‚ฌ์ด์ฆˆ ์ตœ์†Œํ™” ๋ฐฑ์—”๋“œ ์ตœ์ ํ™” ์—ฐ๊ฒฐ ํ’€๋ง ๋ฐ์ดํ„ฐ ์••์ถ• ์บ์‹ฑ ์ „๋žต ๋กœ๋“œ ๋ฐธ๋Ÿฐ์‹ฑ DB ์ฟผ๋ฆฌ ์ตœ์ ํ™” ๋ฉ”์‹œ์ง€ ํ ํ™œ์šฉ ์ˆ˜ํ‰ ํ™•์žฅ ๋ชจ๋‹ˆํ„ฐ๋ง ์‹œ์Šคํ…œ

๐Ÿ” ๋ณด์•ˆ๊ณผ ์•ˆ์ •์„ฑ - ์‹ค์ „ ๋…ธํ•˜์šฐ

์‹ค์‹œ๊ฐ„ ์‹œ์Šคํ…œ์€ ํ•ญ์ƒ ์—ฐ๊ฒฐ๋˜์–ด ์žˆ์–ด์„œ ๋ณด์•ˆ์ด ๋”์šฑ ์ค‘์š”ํ•ด์š”! ํ•œ ๋ฒˆ ๋šซ๋ฆฌ๋ฉด ๊ณ„์† ๋ฐ์ดํ„ฐ๊ฐ€ ์ƒˆ๋‚˜๊ฐˆ ์ˆ˜ ์žˆ๊ฑฐ๋“ ์š” ใ… ใ… 

๐Ÿ›ก๏ธ WebSocket ๋ณด์•ˆ ๊ฐ•ํ™”

// ์•ˆ์ „ํ•œ WebSocket ์—ฐ๊ฒฐ ๊ตฌํ˜„
class SecureWebSocket {
    constructor(url, options = {}) {
        this.url = url;
        this.options = options;
        this.ws = null;
        this.reconnectAttempts = 0;
        this.maxReconnectAttempts = 5;
        this.reconnectDelay = 1000;
        this.heartbeatInterval = null;
    }
    
    connect() {
        // WSS (WebSocket Secure) ์‚ฌ์šฉ
        const token = this.getAuthToken();
        const wsUrl = `${this.url}?token=${token}`;
        
        this.ws = new WebSocket(wsUrl);
        
        this.ws.onopen = () => {
            console.log('๋ณด์•ˆ ์—ฐ๊ฒฐ ์„ฑ๊ณต โœ…');
            this.reconnectAttempts = 0;
            this.startHeartbeat();
        };
        
        this.ws.onmessage = (event) => {
            try {
                const data = JSON.parse(event.data);
                
                // ๋ฉ”์‹œ์ง€ ๊ฒ€์ฆ
                if (this.validateMessage(data)) {
                    this.handleMessage(data);
                } else {
                    console.warn('์œ ํšจํ•˜์ง€ ์•Š์€ ๋ฉ”์‹œ์ง€:', data);
                }
            } catch (error) {
                console.error('๋ฉ”์‹œ์ง€ ํŒŒ์‹ฑ ์—๋Ÿฌ:', error);
            }
        };
        
        this.ws.onerror = (error) => {
            console.error('WebSocket ์—๋Ÿฌ:', error);
        };
        
        this.ws.onclose = () => {
            console.log('์—ฐ๊ฒฐ ์ข…๋ฃŒ๋จ');
            this.stopHeartbeat();
            this.attemptReconnect();
        };
    }
    
    getAuthToken() {
        // JWT ํ† ํฐ ๊ฐ€์ ธ์˜ค๊ธฐ
        return localStorage.getItem('auth_token') || '';
    }
    
    validateMessage(data) {
        // ๋ฉ”์‹œ์ง€ ๊ตฌ์กฐ ๊ฒ€์ฆ
        if (!data || typeof data !== 'object') return false;
        if (!data.type || !data.timestamp) return false;
        
        // ํƒ€์ž„์Šคํƒฌํ”„ ๊ฒ€์ฆ (5์ดˆ ์ด๋‚ด)
        const now = Date.now();
        const messageTime = new Date(data.timestamp).getTime();
        if (Math.abs(now - messageTime) > 5000) {
            console.warn('์˜ค๋ž˜๋œ ๋ฉ”์‹œ์ง€ ๋ฌด์‹œ');
            return false;
        }
        
        return true;
    }
    
    startHeartbeat() {
        // 30์ดˆ๋งˆ๋‹ค ํ•‘ ์ „์†ก
        this.heartbeatInterval = setInterval(() => {
            if (this.ws.readyState === WebSocket.OPEN) {
                this.ws.send(JSON.stringify({ type: 'ping' }));
            }
        }, 30000);
    }
    
    stopHeartbeat() {
        if (this.heartbeatInterval) {
            clearInterval(this.heartbeatInterval);
            this.heartbeatInterval = null;
        }
    }
    
    attemptReconnect() {
        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
            console.error('์ตœ๋Œ€ ์žฌ์—ฐ๊ฒฐ ์‹œ๋„ ํšŸ์ˆ˜ ์ดˆ๊ณผ');
            return;
        }
        
        this.reconnectAttempts++;
        const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
        
        console.log(`${delay}ms ํ›„ ์žฌ์—ฐ๊ฒฐ ์‹œ๋„ (${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
        
        setTimeout(() => {
            this.connect();
        }, delay);
    }
    
    send(data) {
        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
            // ๋ฐ์ดํ„ฐ ์•”ํ˜ธํ™” (ํ•„์š”์‹œ)
            const encrypted = this.encryptData(data);
            this.ws.send(JSON.stringify(encrypted));
        } else {
            console.warn('WebSocket์ด ์—ฐ๊ฒฐ๋˜์ง€ ์•Š์Œ');
        }
    }
    
    encryptData(data) {
        // ์‹ค์ œ ํ™˜๊ฒฝ์—์„œ๋Š” ์ ์ ˆํ•œ ์•”ํ˜ธํ™” ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ ์‚ฌ์šฉ
        // ์˜ˆ: CryptoJS, Web Crypto API ๋“ฑ
        return {
            ...data,
            timestamp: Date.now(),
            checksum: this.calculateChecksum(data)
        };
    }
    
    calculateChecksum(data) {
        // ๊ฐ„๋‹จํ•œ ์ฒดํฌ์„ฌ (์‹ค์ œ๋กœ๋Š” ๋” ๊ฐ•๋ ฅํ•œ ํ•ด์‹œ ์‚ฌ์šฉ)
        return JSON.stringify(data).split('').reduce((a, b) => {
            a = ((a << 5) - a) + b.charCodeAt(0);
            return a & a;
        }, 0);
    }
    
    handleMessage(data) {
        // ๋ฉ”์‹œ์ง€ ํƒ€์ž…๋ณ„ ์ฒ˜๋ฆฌ
        if (this.options.onMessage) {
            this.options.onMessage(data);
        }
    }
    
    close() {
        this.stopHeartbeat();
        if (this.ws) {
            this.ws.close();
        }
    }
}

// ์‚ฌ์šฉ ์˜ˆ์‹œ
const secureWs = new SecureWebSocket('wss://api.example.com/realtime', {
    onMessage: (data) => {
        console.log('์•ˆ์ „ํ•˜๊ฒŒ ์ˆ˜์‹ ๋œ ๋ฐ์ดํ„ฐ:', data);
        updateVisualization(data);
    }
});

secureWs.connect();

๐Ÿ”’ ์„œ๋ฒ„ ์ธก ๋ณด์•ˆ ๊ตฌํ˜„

// Node.js + Express + ws ๋ณด์•ˆ ๊ตฌํ˜„
const express = require('express');
const https = require('https');
const WebSocket = require('ws');
const jwt = require('jsonwebtoken');
const rateLimit = require('express-rate-limit');

const app = express();

// Rate Limiting
const limiter = rateLimit({
    windowMs: 15 * 60 * 1000, // 15๋ถ„
    max: 100 // ์ตœ๋Œ€ 100 ์š”์ฒญ
});

app.use(limiter);

// HTTPS ์„œ๋ฒ„ ์ƒ์„ฑ
const server = https.createServer({
    cert: fs.readFileSync('cert.pem'),
    key: fs.readFileSync('key.pem')
}, app);

const wss = new WebSocket.Server({ 
    server,
    verifyClient: (info, callback) => {
        // ์—ฐ๊ฒฐ ์ „ ์ธ์ฆ ๊ฒ€์ฆ
        const token = new URL(info.req.url, 'wss://localhost').searchParams.get('token');
        
        if (!token) {
            callback(false, 401, 'Unauthorized');
            return;
        }
        
        jwt.verify(token, process.env.JWT_SECRET, (err, decoded) => {
            if (err) {
                callback(false, 401, 'Invalid token');
            } else {
                info.req.user = decoded;
                callback(true);
            }
        });
    }
});

// ํด๋ผ์ด์–ธํŠธ๋ณ„ ๋ฉ”์‹œ์ง€ ์ œํ•œ
const clientMessageLimits = new Map();

wss.on('connection', (ws, req) => {
    const userId = req.user.id;
    console.log(`์‚ฌ์šฉ์ž ${userId} ์—ฐ๊ฒฐ๋จ`);
    
    // ๋ฉ”์‹œ์ง€ ์นด์šดํ„ฐ ์ดˆ๊ธฐํ™”
    clientMessageLimits.set(ws, {
        count: 0,
        resetTime: Date.now() + 60000 // 1๋ถ„
    });
    
    ws.on('message', (message) => {
        // Rate limiting ์ฒดํฌ
        const limit = clientMessageLimits.get(ws);
        const now = Date.now();
        
        if (now > limit.resetTime) {
            limit.count = 0;
            limit.resetTime = now + 60000;
        }
        
        limit.count++;
        
        if (limit.count > 60) { // ๋ถ„๋‹น 60๊ฐœ ์ œํ•œ
            ws.send(JSON.stringify({
                type: 'error',
                message: 'Rate limit exceeded'
            }));
            return;
        }
        
        try {
            const data = JSON.parse(message);
            
            // ์ž…๋ ฅ ๊ฒ€์ฆ
            if (!validateInput(data)) {
                ws.send(JSON.stringify({
                    type: 'error',
                    message: 'Invalid input'
                }));
                return;
            }
            
            // ๋ฉ”์‹œ์ง€ ์ฒ˜๋ฆฌ
            handleClientMessage(ws, data, userId);
            
        } catch (error) {
            console.error('๋ฉ”์‹œ์ง€ ์ฒ˜๋ฆฌ ์—๋Ÿฌ:', error);
        }
    });
    
    ws.on('close', () => {
        console.log(`์‚ฌ์šฉ์ž ${userId} ์—ฐ๊ฒฐ ์ข…๋ฃŒ`);
        clientMessageLimits.delete(ws);
    });
    
    // ํ•‘/ํ์œผ๋กœ ์—ฐ๊ฒฐ ์œ ์ง€ ํ™•์ธ
    ws.isAlive = true;
    ws.on('pong', () => {
        ws.isAlive = true;
    });
});

// 30์ดˆ๋งˆ๋‹ค ์—ฐ๊ฒฐ ์ƒํƒœ ํ™•์ธ
const interval = setInterval(() => {
    wss.clients.forEach((ws) => {
        if (ws.isAlive === false) {
            return ws.terminate();
        }
        
        ws.isAlive = false;
        ws.ping();
    });
}, 30000);

wss.on('close', () => {
    clearInterval(interval);
});

function validateInput(data) {
    // ์ž…๋ ฅ ๊ฒ€์ฆ ๋กœ์ง
    if (!data || typeof data !== 'object') return false;
    if (typeof data.type !== 'string') return false;
    if (data.type.length > 50) return false; // ํƒ€์ž… ๊ธธ์ด ์ œํ•œ
    
    // XSS ๋ฐฉ์ง€
    const dangerousPatterns = /<script|javascript:|onerror=/i;
    const dataStr = JSON.stringify(data);
    if (dangerousPatterns.test(dataStr)) return false;
    
    return true;
}

function handleClientMessage(ws, data, userId) {
    // ๊ถŒํ•œ ์ฒดํฌ
    if (!hasPermission(userId, data.type)) {
        ws.send(JSON.stringify({
            type: 'error',
            message: 'Permission denied'
        }));
        return;
    }
    
    // ๋น„์ฆˆ๋‹ˆ์Šค ๋กœ์ง ์ฒ˜๋ฆฌ
    // ...
}

server.listen(8443, () => {
    console.log('๋ณด์•ˆ WebSocket ์„œ๋ฒ„ ์‹œ์ž‘: wss://localhost:8443');
});

๐Ÿ” ๋ณด์•ˆ ์ฒดํฌ๋ฆฌ์ŠคํŠธ

โœ… WSS (WebSocket Secure) ์‚ฌ์šฉ - TLS/SSL ์•”ํ˜ธํ™”
โœ… JWT ํ† ํฐ ๊ธฐ๋ฐ˜ ์ธ์ฆ
โœ… Rate Limiting - DDoS ๋ฐฉ์–ด
โœ… ์ž…๋ ฅ ๊ฒ€์ฆ - XSS, Injection ๋ฐฉ์ง€
โœ… ๋ฉ”์‹œ์ง€ ํƒ€์ž„์Šคํƒฌํ”„ ๊ฒ€์ฆ
โœ… ์—ฐ๊ฒฐ ์ƒํƒœ ๋ชจ๋‹ˆํ„ฐ๋ง (Heartbeat)
โœ… ์—๋Ÿฌ ํ•ธ๋“ค๋ง ๋ฐ ๋กœ๊น…
โœ… CORS ์ •์ฑ… ์„ค์ •

๐ŸŽจ ์‹ค์ „ ํ”„๋กœ์ ํŠธ - ์‹ค์‹œ๊ฐ„ ์ฃผ์‹ ์ฐจํŠธ ๋งŒ๋“ค๊ธฐ

์ด๋ก ๋งŒ ๋ฐฐ์šฐ๋ฉด ์žฌ๋ฏธ์—†์ž–์•„์š” ใ…‹ใ…‹ ์‹ค์ œ๋กœ ๋™์ž‘ํ•˜๋Š” ์‹ค์‹œ๊ฐ„ ์ฃผ์‹ ์ฐจํŠธ๋ฅผ ๋งŒ๋“ค์–ด๋ณผ๊ฒŒ์š”! ์ด๊ฑฐ ์™„์„ฑํ•˜๋ฉด ํฌํŠธํด๋ฆฌ์˜ค์— ๋„ฃ๊ธฐ ๋”ฑ ์ข‹์•„์š” ๐Ÿ’ช

๐Ÿ“ ํ”„๋กœ์ ํŠธ ๊ตฌ์กฐ

realtime-stock-chart/
โ”œโ”€โ”€ client/
โ”‚   โ”œโ”€โ”€ index.html
โ”‚   โ”œโ”€โ”€ app.js
โ”‚   โ””โ”€โ”€ styles.css
โ”œโ”€โ”€ server/
โ”‚   โ”œโ”€โ”€ server.js
โ”‚   โ”œโ”€โ”€ stockData.js
โ”‚   โ””โ”€โ”€ websocket.js
โ”œโ”€โ”€ package.json
โ””โ”€โ”€ README.md

๐Ÿ–ฅ๏ธ ํด๋ผ์ด์–ธํŠธ ๊ตฌํ˜„

<!-- index.html -->
<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>์‹ค์‹œ๊ฐ„ ์ฃผ์‹ ์ฐจํŠธ</title>
    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
    <link rel="stylesheet" href="styles.css">
</head>
<body>
    <div class="container">
        <header>
            <h1>๐Ÿ“ˆ ์‹ค์‹œ๊ฐ„ ์ฃผ์‹ ๋ชจ๋‹ˆํ„ฐ๋ง</h1>
            <div class="status" id="status">์—ฐ๊ฒฐ ์ค‘...</div>
        </header>
        
        <div class="stock-selector">
            <button class="stock-btn active" data-symbol="AAPL">Apple</button>
            <button class="stock-btn" data-symbol="GOOGL">Google</button>
            <button class="stock-btn" data-symbol="MSFT">Microsoft</button>
            <button class="stock-btn" data-symbol="TSLA">Tesla</button>
        </div>
        
        <div class="chart-container">
            <canvas id="stockChart"></canvas>
        </div>
        
        <div class="stats-grid">
            <div class="stat-card">
                <div class="stat-label">ํ˜„์žฌ๊ฐ€</div>
                <div class="stat-value" id="currentPrice">-</div>
            </div>
            <div class="stat-card">
                <div class="stat-label">๋ณ€๋™๋ฅ </div>
                <div class="stat-value" id="changePercent">-</div>
            </div>
            <div class="stat-card">
                <div class="stat-label">๊ฑฐ๋ž˜๋Ÿ‰</div>
                <div class="stat-value" id="volume">-</div>
            </div>
            <div class="stat-card">
                <div class="stat-label">์ตœ๊ณ ๊ฐ€</div>
                <div class="stat-value" id="highPrice">-</div>
            </div>
        </div>
    </div>
    
    <script src="app.js"></script>
</body>
</html>
// app.js - ํด๋ผ์ด์–ธํŠธ ๋กœ์ง
class StockChartApp {
    constructor() {
        this.ws = null;
        this.chart = null;
        this.currentSymbol = 'AAPL';
        this.maxDataPoints = 50;
        this.data = {
            labels: [],
            prices: []
        };
        
        this.init();
    }
    
    init() {
        this.setupChart();
        this.connectWebSocket();
        this.setupEventListeners();
    }
    
    setupChart() {
        const ctx = document.getElementById('stockChart').getContext('2d');
        
        this.chart = new Chart(ctx, {
            type: 'line',
            data: {
                labels: [],
                datasets: [{
                    label: '์ฃผ๊ฐ€',
                    data: [],
                    borderColor: '#667eea',
                    backgroundColor: 'rgba(102, 126, 234, 0.1)',
                    borderWidth: 2,
                    tension: 0.4,
                    fill: true,
                    pointRadius: 0,
                    pointHoverRadius: 5
                }]
            },
            options: {
                responsive: true,
                maintainAspectRatio: false,
                animation: {
                    duration: 0
                },
                scales: {
                    x: {
                        display: true,
                        grid: {
                            display: false
                        }
                    },
                    y: {
                        display: true,
                        grid: {
                            color: 'rgba(0, 0, 0, 0.05)'
                        }
                    }
                },
                plugins: {
                    legend: {
                        display: false
                    },
                    tooltip: {
                        mode: 'index',
                        intersect: false
                    }
                },
                interaction: {
                    mode: 'nearest',
                    axis: 'x',
                    intersect: false
                }
            }
        });
    }
    
    connectWebSocket() {
        const wsUrl = 'ws://localhost:8080';
        this.ws = new WebSocket(wsUrl);
        
        this.ws.onopen = () => {
            console.log('WebSocket ์—ฐ๊ฒฐ ์„ฑ๊ณต! ๐ŸŽ‰');
            this.updateStatus('์—ฐ๊ฒฐ๋จ', 'connected');
            this.subscribe(this.currentSymbol);
        };
        
        this.ws.onmessage = (event) => {
            const data = JSON.parse(event.data);
            this.handleStockData(data);
        };
        
        this.ws.onerror = (error) => {
            console.error('WebSocket ์—๋Ÿฌ:', error);
            this.updateStatus('์—๋Ÿฌ ๋ฐœ์ƒ', 'error');
        };
        
        this.ws.onclose = () => {
            console.log('WebSocket ์—ฐ๊ฒฐ ์ข…๋ฃŒ');
            this.updateStatus('์—ฐ๊ฒฐ ๋Š๊น€', 'disconnected');
            
            // 3์ดˆ ํ›„ ์žฌ์—ฐ๊ฒฐ ์‹œ๋„
            setTimeout(() => {
                this.connectWebSocket();
            }, 3000);
        };
    }
    
    subscribe(symbol) {
        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
            this.ws.send(JSON.stringify({
                type: 'subscribe',
                symbol: symbol
            }));
            
            // ๋ฐ์ดํ„ฐ ์ดˆ๊ธฐํ™”
            this.data.labels = [];
            this.data.prices = [];
            this.chart.data.labels = [];
            this.chart.data.datasets[0].data = [];
            this.chart.update();
        }
    }
    
    handleStockData(data) {
        if (data.symbol !== this.currentSymbol) return;
        
        const time = new Date(data.timestamp).toLocaleTimeString();
        
        // ๋ฐ์ดํ„ฐ ์ถ”๊ฐ€
        this.data.labels.push(time);
        this.data.prices.push(data.price);
        
        // ์ตœ๋Œ€ ๊ฐœ์ˆ˜ ์œ ์ง€
        if (this.data.labels.length > this.maxDataPoints) {
            this.data.labels.shift();
            this.data.prices.shift();
        }
        
        // ์ฐจํŠธ ์—…๋ฐ์ดํŠธ
        this.chart.data.labels = this.data.labels;
        this.chart.data.datasets[0].data = this.data.prices;
        this.chart.update('none');
        
        // ํ†ต๊ณ„ ์—…๋ฐ์ดํŠธ
        this.updateStats(data);
    }
    
    updateStats(data) {
        document.getElementById('currentPrice').textContent = 
            `$${data.price.toFixed(2)}`;
        
        const changePercent = data.changePercent || 0;
        const changeElem = document.getElementById('changePercent');
        changeElem.textContent = `${changePercent > 0 ? '+' : ''}${changePercent.toFixed(2)}%`;
        changeElem.style.color = changePercent >= 0 ? '#10b981' : '#ef4444';
        
        document.getElementById('volume').textContent = 
            this.formatNumber(data.volume);
        
        document.getElementById('highPrice').textContent = 
            `$${data.high.toFixed(2)}`;
    }
    
    updateStatus(text, status) {
        const statusElem = document.getElementById('status');
        statusElem.textContent = text;
        statusElem.className = `status ${status}`;
    }
    
    formatNumber(num) {
        if (num >= 1000000) {
            return (num / 1000000).toFixed(1) + 'M';
        } else if (num >= 1000) {
            return (num / 1000).toFixed(1) + 'K';
        }
        return num.toString();
    }
    
    setupEventListeners() {
        const buttons = document.querySelectorAll('.stock-btn');
        
        buttons.forEach(btn => {
            btn.addEventListener('click', () => {
                // ํ™œ์„ฑ ๋ฒ„ํŠผ ๋ณ€๊ฒฝ
                buttons.forEach(b => b.classList.remove('active'));
                btn.classList.add('active');
                
                // ์‹ฌ๋ณผ ๋ณ€๊ฒฝ
                this.currentSymbol = btn.dataset.symbol;
                this.subscribe(this.currentSymbol);
            });
        });
    }
}

// ์•ฑ ์‹œ์ž‘
const app = new StockChartApp();

โš™๏ธ ์„œ๋ฒ„ ๊ตฌํ˜„

// server.js
const express = require('express');
const http = require('http');
const WebSocket = require('ws');
const path = require('path');
const StockDataGenerator = require('./stockData');

const app = express();
const server = http.createServer(app);
const wss = new WebSocket.Server({ server });

// ์ •์  ํŒŒ์ผ ์ œ๊ณต
app.use(express.static(path.join(__dirname, '../client')));

// ์ฃผ์‹ ๋ฐ์ดํ„ฐ ์ƒ์„ฑ๊ธฐ
const stockGenerator = new StockDataGenerator();

// WebSocket ์—ฐ๊ฒฐ ๊ด€๋ฆฌ
const clients = new Map();

wss.on('connection', (ws) => {
    console.log('์ƒˆ ํด๋ผ์ด์–ธํŠธ ์—ฐ๊ฒฐ๋จ');
    
    const clientId = generateClientId();
    clients.set(clientId, {
        ws: ws,
        subscriptions: new Set()
    });
    
    ws.on('message', (message) => {
        try {
            const data = JSON.parse(message);
            handleClientMessage(clientId, data);
        } catch (error) {
            console.error('๋ฉ”์‹œ์ง€ ํŒŒ์‹ฑ ์—๋Ÿฌ:', error);
        }
    });
    
    ws.on('close', () => {
        console.log('ํด๋ผ์ด์–ธํŠธ ์—ฐ๊ฒฐ ์ข…๋ฃŒ');
        const client = clients.get(clientId);
        if (client) {
            client.subscriptions.forEach(symbol => {
                stockGenerator.unsubscribe(symbol, clientId);
            });
        }
        clients.delete(clientId);
    });
});

function handleClientMessage(clientId, data) {
    const client = clients.get(clientId);
    if (!client) return;
    
    if (data.type === 'subscribe') {
        const symbol = data.symbol;
        
        // ๊ธฐ์กด ๊ตฌ๋… ์ทจ์†Œ
        client.subscriptions.forEach(oldSymbol => {
            stockGenerator.unsubscribe(oldSymbol, clientId);
        });
        client.subscriptions.clear();
        
        // ์ƒˆ ๊ตฌ๋… ์ถ”๊ฐ€
        client.subscriptions.add(symbol);
        stockGenerator.subscribe(symbol, (stockData) => {
            if (client.ws.readyState === WebSocket.OPEN) {
                client.ws.send(JSON.stringify(stockData));
            }
        }, clientId);
        
        console.log(`ํด๋ผ์ด์–ธํŠธ ${clientId}๊ฐ€ ${symbol} ๊ตฌ๋…`);
    }
}

function generateClientId() {
    return Math.random().toString(36).substr(2, 9);
}

const PORT = process.env.PORT || 8080;
server.listen(PORT, () => {
    console.log(`์„œ๋ฒ„ ์‹œ์ž‘: http://localhost:${PORT}`);
});
// stockData.js - ์ฃผ์‹ ๋ฐ์ดํ„ฐ ์ƒ์„ฑ๊ธฐ
class StockDataGenerator {
    constructor() {
        this.stocks = {
            'AAPL': { price: 150, volatility: 2 },
            'GOOGL': { price: 2800, volatility: 30 },
            'MSFT': { price: 300, volatility: 3 },
            'TSLA': { price: 700, volatility: 15 }
        };
        
        this.subscribers = new Map();
        this.intervals = new Map();
    }
    
    subscribe(symbol, callback, clientId) {
        if (!this.subscribers.has(symbol)) {
            this.subscribers.set(symbol, new Map());
        }
        
        this.subscribers.get(symbol).set(clientId, callback);
        
        // ํ•ด๋‹น ์‹ฌ๋ณผ์˜ ๋ฐ์ดํ„ฐ ์ƒ์„ฑ ์‹œ์ž‘
        if (!this.intervals.has(symbol)) {
            this.startGenerating(symbol);
        }
    }
    
    unsubscribe(symbol, clientId) {
        if (this.subscribers.has(symbol)) {
            this.subscribers.get(symbol).delete(clientId);
            
            // ๊ตฌ๋…์ž๊ฐ€ ์—†์œผ๋ฉด ์ƒ์„ฑ ์ค‘์ง€
            if (this.subscribers.get(symbol).size === 0) {
                this.stopGenerating(symbol);
                this.subscribers.delete(symbol);
            }
        }
    }
    
    startGenerating(symbol) {
        const interval = setInterval(() => {
            const data = this.generateStockData(symbol);
            this.broadcast(symbol, data);
        }, 1000); // 1์ดˆ๋งˆ๋‹ค ๋ฐ์ดํ„ฐ ์ƒ์„ฑ
        
        this.intervals.set(symbol, interval);
    }
    
    stopGenerating(symbol) {
        if (this.intervals.has(symbol)) {
            clearInterval(this.intervals.get(symbol));
            this.intervals.delete(symbol);
        }
    }
    
    generateStockData(symbol) {
        const stock = this.stocks[symbol];
        
        // ๋žœ๋ค ์›Œํฌ๋กœ ๊ฐ€๊ฒฉ ๋ณ€๋™
        const change = (Math.random() - 0.5) * stock.volatility;
        stock.price += change;
        
        // ๊ฐ€๊ฒฉ์ด ๋„ˆ๋ฌด ๋‚ฎ์•„์ง€์ง€ ์•Š๋„๋ก
        if (stock.price < 10) stock.price = 10;
        
        const changePercent = (change / stock.price) * 100;
        
        return {
            symbol: symbol,
            price: stock.price,
            changePercent: changePercent,
            volume: Math.floor(Math.random() * 1000000) + 500000,
            high: stock.price + Math.random() * stock.volatility,
            low: stock.price - Math.random() * stock.volatility,
            timestamp: Date.now()
        };
    }
    
    broadcast(symbol, data) {
        if (this.subscribers.has(symbol)) {
            this.subscribers.get(symbol).forEach(callback => {
                callback(data);
            });
        }
    }
}

module.exports = StockDataGenerator;

๐Ÿš€ ํ”„๋กœ์ ํŠธ ์‹คํ–‰ ๋ฐฉ๋ฒ•

1. ์˜์กด์„ฑ ์„ค์น˜: npm install express ws
2. ์„œ๋ฒ„ ์‹œ์ž‘: node server/server.js
3. ๋ธŒ๋ผ์šฐ์ €์—์„œ http://localhost:8080 ์ ‘์†
4. ์‹ค์‹œ๊ฐ„์œผ๋กœ ๋ณ€ํ•˜๋Š” ์ฃผ์‹ ์ฐจํŠธ ํ™•์ธ! ๐ŸŽ‰

๐ŸŒ ์‹ค๋ฌด์—์„œ ์ž์ฃผ ์“ฐ๋Š” ๊ณ ๊ธ‰ ํŒจํ„ด

์ด์ œ ์ข€ ๋” ์‹ค๋ฌด์ ์ธ ์–˜๊ธฐ๋ฅผ ํ•ด๋ณผ๊ฒŒ์š”! ์‹ค์ œ ํ”„๋กœ๋•์…˜ ํ™˜๊ฒฝ์—์„œ ์“ฐ์ด๋Š” ํŒจํ„ด๋“ค์ด์—์š” ใ…Žใ…Ž

๐Ÿ”„ ๋ฐ์ดํ„ฐ ์ŠคํŠธ๋ฆผ ํŒŒ์ดํ”„๋ผ์ธ

๋Œ€๊ทœ๋ชจ ์‹ค์‹œ๊ฐ„ ์‹œ์Šคํ…œ์—์„œ๋Š” ๋ฐ์ดํ„ฐ๊ฐ€ ์—ฌ๋Ÿฌ ๋‹จ๊ณ„๋ฅผ ๊ฑฐ์ณ์„œ ์ฒ˜๋ฆฌ๋ผ์š”. ์ด๊ฑธ ํŒŒ์ดํ”„๋ผ์ธ ํŒจํ„ด์œผ๋กœ ๊ตฌํ˜„ํ•˜๋ฉด ๊น”๋”ํ•ด์š”!

// ๋ฐ์ดํ„ฐ ํŒŒ์ดํ”„๋ผ์ธ ๊ตฌํ˜„
class DataPipeline {
    constructor() {
        this.stages = [];
    }
    
    addStage(stage) {
        this.stages.push(stage);
        return this;
    }
    
    async process(data) {
        let result = data;
        
        for (const stage of this.stages) {
            try {
                result = await stage.execute(result);
            } catch (error) {
                console.error(`Stage ${stage.name} ์—๋Ÿฌ:`, error);
                throw error;
            }
        }
        
        return result;
    }
}

// ํŒŒ์ดํ”„๋ผ์ธ ์Šคํ…Œ์ด์ง€๋“ค
class ValidationStage {
    constructor() {
        this.name = 'Validation';
    }
    
    async execute(data) {
        // ๋ฐ์ดํ„ฐ ๊ฒ€์ฆ
        if (!data || typeof data !== 'object') {
            throw new Error('Invalid data format');
        }
        
        if (!data.timestamp || !data.value) {
            throw new Error('Missing required fields');
        }
        
        return data;
    }
}

class TransformationStage {
    constructor() {
        this.name = 'Transformation';
    }
    
    async execute(data) {
        // ๋ฐ์ดํ„ฐ ๋ณ€ํ™˜
        return {
            ...data,
            value: parseFloat(data.value),
            timestamp: new Date(data.timestamp),
            processedAt: new Date()
        };
    }
}

class EnrichmentStage {
    constructor() {
        this.name = 'Enrichment';
        this.cache = new Map();
    }
    
    async execute(data) {
        // ์ถ”๊ฐ€ ์ •๋ณด ๋ณด๊ฐ•
        const metadata = await this.fetchMetadata(data.id);
        
        return {
            ...data,
            metadata: metadata
        };
    }
    
    async fetchMetadata(id) {
        // ์บ์‹œ ํ™•์ธ
        if (this.cache.has(id)) {
            return this.cache.get(id);
        }
        
        // API ํ˜ธ์ถœ (์‹œ๋ฎฌ๋ ˆ์ด์…˜)
        const metadata = {
            category: 'sensor',
            location: 'Building A',
            unit: 'celsius'
        };
        
        this.cache.set(id, metadata);
        return metadata;
    }
}

class AggregationStage {
    constructor(windowSize = 5) {
        this.name = 'Aggregation';
        this.windowSize = windowSize;
        this.buffer = [];
    }
    
    async execute(data) {
        this.buffer.push(data);
        
        if (this.buffer.length > this.windowSize) {
            this.buffer.shift();
        }
        
        // ์œˆ๋„์šฐ ๋‚ด ํ†ต๊ณ„ ๊ณ„์‚ฐ
        const values = this.buffer.map(d => d.value);
        const avg = values.reduce((a, b) => a + b, 0) / values.length;
        const max = Math.max(...values);
        const min = Math.min(...values);
        
        return {
            ...data,
            statistics: {
                average: avg,
                max: max,
                min: min,
                count: this.buffer.length
            }
        };
    }
}

// ํŒŒ์ดํ”„๋ผ์ธ ๊ตฌ์„ฑ ๋ฐ ์‚ฌ์šฉ
const pipeline = new DataPipeline()
    .addStage(new ValidationStage())
    .addStage(new TransformationStage())
    .addStage(new EnrichmentStage())
    .addStage(new AggregationStage(10));

// WebSocket์œผ๋กœ ๋ฐ›์€ ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ
socket.onmessage = async function(event) {
    try {
        const rawData = JSON.parse(event.data);
        const processedData = await pipeline.process(rawData);
        
        // ์‹œ๊ฐํ™” ์—…๋ฐ์ดํŠธ
        updateVisualization(processedData);
    } catch (error) {
        console.error('ํŒŒ์ดํ”„๋ผ์ธ ์ฒ˜๋ฆฌ ์—๋Ÿฌ:', error);
    }
};

๐Ÿ“ฆ ์ƒํƒœ ๊ด€๋ฆฌ ํŒจํ„ด

๋ณต์žกํ•œ ์‹ค์‹œ๊ฐ„ ์•ฑ์—์„œ๋Š” ์ƒํƒœ ๊ด€๋ฆฌ๊ฐ€ ์ง„์งœ ์ค‘์š”ํ•ด์š”! Redux ๊ฐ™์€ ๊ฑฐ ์“ฐ๋ฉด ์ข‹์€๋ฐ, ๊ฐ„๋‹จํ•œ ๋ฒ„์ „์„ ๋งŒ๋“ค์–ด๋ณผ๊ฒŒ์š”.

// ์‹ค์‹œ๊ฐ„ ๋ฐ์ดํ„ฐ์šฉ ์ƒํƒœ ๊ด€๋ฆฌ
class RealtimeStore {
    constructor(initialState = {}) {
        this.state = initialState;
        this.listeners = new Set();
        this.history = [];
        this.maxHistory = 100;
    }
    
    getState() {
        return { ...this.state };
    }
    
    setState(updates) {
        const oldState = this.state;
        this.state = {
            ...this.state,
            ...updates,
            lastUpdated: Date.now()
        };
        
        // ํžˆ์Šคํ† ๋ฆฌ ์ €์žฅ
        this.history.push({
            timestamp: Date.now(),
            state: { ...this.state }
        });
        
        if (this.history.length > this.maxHistory) {
            this.history.shift();
        }
        
        // ๋ฆฌ์Šค๋„ˆ๋“ค์—๊ฒŒ ์•Œ๋ฆผ
        this.notifyListeners(oldState, this.state);
    }
    
    subscribe(listener) {
        this.listeners.add(listener);
        
        // ๊ตฌ๋… ํ•ด์ œ ํ•จ์ˆ˜ ๋ฐ˜ํ™˜
        return () => {
            this.listeners.delete(listener);
        };
    }
    
    notifyListeners(oldState, newState) {
        this.listeners.forEach(listener => {
            try {
                listener(newState, oldState);
            } catch (error) {
                console.error('๋ฆฌ์Šค๋„ˆ ์—๋Ÿฌ:', error);
            }
        });
    }
    
    getHistory(duration = 60000) {
        const cutoff = Date.now() - duration;
        return this.history.filter(entry => entry.timestamp > cutoff);
    }
    
    // ์‹œ๊ณ„์—ด ๋ฐ์ดํ„ฐ ์ถ”๊ฐ€
    addTimeSeries(key, value) {
        const series = this.state[key] || [];
        series.push({
            timestamp: Date.now(),
            value: value
        });
        
        // ์ตœ๋Œ€ 100๊ฐœ ์œ ์ง€
        if (series.length > 100) {
            series.shift();
        }
        
        this.setState({ [key]: series });
    }
}

// ์‚ฌ์šฉ ์˜ˆ์‹œ
const store = new RealtimeStore({
    temperature: [],
    humidity: [],
    pressure: [],
    alerts: []
});

// ์ƒํƒœ ๋ณ€ํ™” ๊ตฌ๋…
const unsubscribe = store.subscribe((newState, oldState) => {
    console.log('์ƒํƒœ ์—…๋ฐ์ดํŠธ:', newState);
    
    // ์˜จ๋„๊ฐ€ ์ž„๊ณ„๊ฐ’ ์ดˆ๊ณผ์‹œ ์•Œ๋ฆผ
    if (newState.temperature.length > 0) {
        const latest = newState.temperature[newState.temperature.length - 1];
        if (latest.value > 30) {
            store.setState({
                alerts: [...newState.alerts, {
                    type: 'warning',
                    message: '์˜จ๋„๊ฐ€ ๋†’์Šต๋‹ˆ๋‹ค!',
                    timestamp: Date.now()
                }]
            });
        }
    }
    
    // ์ฐจํŠธ ์—…๋ฐ์ดํŠธ
    updateCharts(newState);
});

// WebSocket ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ
socket.onmessage = function(event) {
    const data = JSON.parse(event.data);
    
    // ์‹œ๊ณ„์—ด ๋ฐ์ดํ„ฐ ์ถ”๊ฐ€
    store.addTimeSeries('temperature', data.temperature);
    store.addTimeSeries('humidity', data.humidity);
    store.addTimeSeries('pressure', data.pressure);
};

// ์ฐจํŠธ ์—…๋ฐ์ดํŠธ ํ•จ์ˆ˜
function updateCharts(state) {
    // ์˜จ๋„ ์ฐจํŠธ
    if (state.temperature) {
        temperatureChart.data.labels = state.temperature.map(d => 
            new Date(d.timestamp).toLocaleTimeString()
        );
        temperatureChart.data.datasets[0].data = state.temperature.map(d => d.value);
        temperatureChart.update('none');
    }
    
    // ์Šต๋„ ์ฐจํŠธ
    if (state.humidity) {
        humidityChart.data.labels = state.humidity.map(d => 
            new Date(d.timestamp).toLocaleTimeString()
        );
        humidityChart.data.datasets[0].data = state.humidity.map(d => d.value);
        humidityChart.update('none');
    }
}

๐ŸŽ“ ์žฌ๋Šฅ๋„ท์—์„œ ๋ฐฐ์šฐ๊ณ  ๊ฐ€๋ฅด์น˜๊ธฐ

์‹ค์‹œ๊ฐ„ ๋ฐ์ดํ„ฐ ์‹œ๊ฐํ™” ๊ฐ™์€ ๊ณ ๊ธ‰ ๊ธฐ์ˆ ์€ ํ˜ผ์ž ๋ฐฐ์šฐ๊ธฐ ์–ด๋ ค์šธ ์ˆ˜ ์žˆ์–ด์š”. ์žฌ๋Šฅ๋„ท์—์„œ๋Š” ์ด๋Ÿฐ ์ „๋ฌธ ๊ธฐ์ˆ ์„ ๊ฐ€์ง„ ๊ฐœ๋ฐœ์ž๋“ค์ด ์ง์ ‘ ๋ฉ˜ํ† ๋ง์„ ํ•ด์ฃผ๊ฑฐ๋“ ์š”! ์‹ค๋ฌด ๊ฒฝํ—˜์ด ํ’๋ถ€ํ•œ ์‹œ๋‹ˆ์–ด ๊ฐœ๋ฐœ์ž์—๊ฒŒ 1:1๋กœ ๋ฐฐ์šธ ์ˆ˜ ์žˆ์–ด์„œ ์ง„์งœ ํšจ์œจ์ ์ด์—์š” ใ…Žใ…Ž

๋ฐ˜๋Œ€๋กœ ์—ฌ๋Ÿฌ๋ถ„์ด ์‹ค์‹œ๊ฐ„ ์‹œ๊ฐํ™” ์ „๋ฌธ๊ฐ€๋ผ๋ฉด? ์žฌ๋Šฅ๋„ท์—์„œ ์—ฌ๋Ÿฌ๋ถ„์˜ ์ง€์‹์„ ๊ณต์œ ํ•˜๊ณ  ์ˆ˜์ต๋„ ์ฐฝ์ถœํ•  ์ˆ˜ ์žˆ์–ด์š”! ์š”์ฆ˜ ์ด๋Ÿฐ ๊ธฐ์ˆ  ์ˆ˜์š”๊ฐ€ ์—„์ฒญ ๋งŽ๊ฑฐ๋“ ์š” ๐Ÿ’ฐ

๐Ÿ’ก ์žฌ๋Šฅ๋„ท์—์„œ ์ธ๊ธฐ ์žˆ๋Š” ์‹ค์‹œ๊ฐ„ ์‹œ๊ฐํ™” ๊ด€๋ จ ์žฌ๋Šฅ๋“ค

โ€ข ์‹ค์‹œ๊ฐ„ ๋Œ€์‹œ๋ณด๋“œ ๊ตฌ์ถ• ๋ฉ˜ํ† ๋ง
โ€ข WebSocket ํ”„๋กœ๊ทธ๋ž˜๋ฐ ๊ฐ•์˜
โ€ข D3.js ๊ณ ๊ธ‰ ์‹œ๊ฐํ™” ํŠœํ† ๋ฆฌ์–ผ
โ€ข ์‹ค์‹œ๊ฐ„ ๋ชจ๋‹ˆํ„ฐ๋ง ์‹œ์Šคํ…œ ๊ตฌ์ถ• ์ปจ์„คํŒ…
โ€ข ์„ฑ๋Šฅ ์ตœ์ ํ™” ๋…ธํ•˜์šฐ ๊ณต์œ 

๐Ÿ”ฅ ํŠธ๋Ÿฌ๋ธ”์ŠˆํŒ… - ์ž์ฃผ ๋งŒ๋‚˜๋Š” ๋ฌธ์ œ๋“ค

์‹ค์ „์—์„œ ์ง„์งœ ๋งŽ์ด ๊ฒช๋Š” ๋ฌธ์ œ๋“ค๊ณผ ํ•ด๊ฒฐ๋ฒ•์„ ์ •๋ฆฌํ•ด๋ดค์–ด์š”!

โŒ ๋ฌธ์ œ 1: ๋ฉ”๋ชจ๋ฆฌ ๋ˆ„์ˆ˜

// ๋‚˜์œ ์˜ˆ - ๋ฉ”๋ชจ๋ฆฌ ๋ˆ„์ˆ˜ ๋ฐœ์ƒ
class BadChart {
    constructor() {
        this.data = [];
        
        setInterval(() => {
            this.data.push(Math.random());
            this.render(); // ๊ณ„์† ์Œ“์ž„!
        }, 1000);
    }
}

// ์ข‹์€ ์˜ˆ - ๋ฉ”๋ชจ๋ฆฌ ๊ด€๋ฆฌ
class GoodChart {
    constructor(maxDataPoints = 50) {
        this.data = [];
        this.maxDataPoints = maxDataPoints;
        this.interval = null;
    }
    
    start() {
        this.interval = setInterval(() => {
            this.data.push(Math.random());
            
            // ์˜ค๋ž˜๋œ ๋ฐ์ดํ„ฐ ์ œ๊ฑฐ
            if (this.data.length > this.maxDataPoints) {
                this.data.shift();
            }
            
            this.render();
        }, 1000);
    }
    
    stop() {
        if (this.interval) {
            clearInterval(this.interval);
            this.interval = null;
        }
    }
    
    destroy() {
        this.stop();
        this.data = null;
    }
}

โŒ ๋ฌธ์ œ 2: ์—ฐ๊ฒฐ ๋Š๊น€ ์ฒ˜๋ฆฌ

// ๊ฐ•๋ ฅํ•œ ์žฌ์—ฐ๊ฒฐ ๋กœ์ง
class RobustWebSocket {
    constructor(url, options = {}) {
        this.url = url;
        this.options = {
            reconnectInterval: 1000,
            maxReconnectInterval: 30000,
            reconnectDecay: 1.5,
            maxReconnectAttempts: null,
            ...options
        };
        
        this.reconnectAttempts = 0;
        this.reconnectTimer = null;
        this.forcedClose = false;
        this.ws = null;
    }
    
    connect() {
        this.forcedClose = false;
        this.ws = new WebSocket(this.url);
        
        this.ws.onopen = (event) => {
            console.log('์—ฐ๊ฒฐ ์„ฑ๊ณต! ๐ŸŽ‰');
            this.reconnectAttempts = 0;
            
            if (this.options.onOpen) {
                this.options.onOpen(event);
            }
        };
        
        this.ws.onmessage = (event) => {
            if (this.options.onMessage) {
                this.options.onMessage(event);
            }
        };
        
        this.ws.onerror = (error) => {
            console.error('WebSocket ์—๋Ÿฌ:', error);
            
            if (this.options.onError) {
                this.options.onError(error);
            }
        };
        
        this.ws.onclose = (event) => {
            console.log('์—ฐ๊ฒฐ ์ข…๋ฃŒ๋จ');
            
            if (this.options.onClose) {
                this.options.onClose(event);
            }
            
            if (!this.forcedClose) {
                this.reconnect();
            }
        };
    }
    
    reconnect() {
        if (this.options.maxReconnectAttempts && 
            this.reconnectAttempts >= this.options.maxReconnectAttempts) {
            console.error('์ตœ๋Œ€ ์žฌ์—ฐ๊ฒฐ ์‹œ๋„ ํšŸ์ˆ˜ ์ดˆ๊ณผ');
            return;
        }
        
        this.reconnectAttempts++;
        
        const timeout = Math.min(
            this.options.reconnectInterval * 
            Math.pow(this.options.reconnectDecay, this.reconnectAttempts - 1),
            this.options.maxReconnectInterval
        );
        
        console.log(`${timeout}ms ํ›„ ์žฌ์—ฐ๊ฒฐ ์‹œ๋„ (${this.reconnectAttempts}๋ฒˆ์งธ)`);
        
        this.reconnectTimer = setTimeout(() => {
            console.log('์žฌ์—ฐ๊ฒฐ ์ค‘...');
            this.connect();
        }, timeout);
    }
    
    send(data) {
        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
            this.ws.send(data);
        } else {
            console.warn('WebSocket์ด ์—ฐ๊ฒฐ๋˜์ง€ ์•Š์Œ');
        }
    }
    
    close() {
        this.forcedClose = true;
        
        if (this.reconnectTimer) {
            clearTimeout(this.reconnectTimer);
        }
        
        if (this.ws) {
            this.ws.close();
        }
    }
}

// ์‚ฌ์šฉ ์˜ˆ์‹œ
const robustWs = new RobustWebSocket('ws://localhost:8080', {
    reconnectInterval: 1000,
    maxReconnectInterval: 30000,
    reconnectDecay: 1.5,
    onOpen: (event) => {
        console.log('์—ฐ๊ฒฐ๋จ!');
    },
    onMessage: (event) => {
        const data = JSON.parse(event.data);
        updateChart(data);
    },
    onError: (error) => {
        console.error('์—๋Ÿฌ:', error);
    },
    onClose: (event) => {
        console.log('์—ฐ๊ฒฐ ์ข…๋ฃŒ');
    }
});

robustWs.connect();

โŒ ๋ฌธ์ œ 3: ์ฐจํŠธ ๋ Œ๋”๋ง ์„ฑ๋Šฅ

// ์„ฑ๋Šฅ ์ตœ์ ํ™”๋œ ์ฐจํŠธ ์—…๋ฐ์ดํŠธ
class OptimizedChart {
    constructor(canvas, options = {}) {
        this.canvas = canvas;
        this.ctx = canvas.getContext('2d');
        this.data = [];
        this.maxPoints = options.maxPoints || 100;
        this.updateThrottle = options.updateThrottle || 16; // 60fps
        this.lastUpdate = 0;
        this.pendingUpdate = false;
        this.offscreenCanvas = null;
        
        // ์˜คํ”„์Šคํฌ๋ฆฐ ์บ”๋ฒ„์Šค ์ƒ์„ฑ (๋”๋ธ” ๋ฒ„ํผ๋ง)
        if (typeof OffscreenCanvas !== 'undefined') {
            this.offscreenCanvas = new OffscreenCanvas(
                canvas.width, 
                canvas.height
            );
            this.offscreenCtx = this.offscreenCanvas.getContext('2d');
        }
    }
    
    addData(value) {
        this.data.push({
            value: value,
            timestamp: Date.now()
        });
        
        if (this.data.length > this.maxPoints) {
            this.data.shift();
        }
        
        this.scheduleUpdate();
    }
    
    scheduleUpdate() {
        if (this.pendingUpdate) return;
        
        const now = Date.now();
        const timeSinceLastUpdate = now - this.lastUpdate;
        
        if (timeSinceLastUpdate >= this.updateThrottle) {
            this.update();
        } else {
            this.pendingUpdate = true;
            setTimeout(() => {
                this.pendingUpdate = false;
                this.update();
            }, this.updateThrottle - timeSinceLastUpdate);
        }
    }
    
    update() {
        this.lastUpdate = Date.now();
        
        // ์˜คํ”„์Šคํฌ๋ฆฐ ์บ”๋ฒ„์Šค์— ๋จผ์ € ๊ทธ๋ฆฌ๊ธฐ
        const ctx = this.offscreenCtx || this.ctx;
        const canvas = this.offscreenCanvas || this.canvas;
        
        // ์บ”๋ฒ„์Šค ํด๋ฆฌ์–ด
        ctx.clearRect(0, 0, canvas.width, canvas.height);
        
        // ๋ฐฐ๊ฒฝ ๊ทธ๋ฆฌ๋“œ
        this.drawGrid(ctx, canvas);
        
        // ๋ฐ์ดํ„ฐ ๋ผ์ธ
        this.drawLine(ctx, canvas);
        
        // ์˜คํ”„์Šคํฌ๋ฆฐ์—์„œ ๋ฉ”์ธ ์บ”๋ฒ„์Šค๋กœ ๋ณต์‚ฌ
        if (this.offscreenCanvas) {
            this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
            this.ctx.drawImage(this.offscreenCanvas, 0, 0);
        }
    }
    
    drawGrid(ctx, canvas) {
        ctx.strokeStyle = 'rgba(0, 0, 0, 0.05)';
        ctx.lineWidth = 1;
        
        // ์ˆ˜ํ‰์„ 
        for (let i = 0; i <= 10; i++) {
            const y = (canvas.height / 10) * i;
            ctx.beginPath();
            ctx.moveTo(0, y);
            ctx.lineTo(canvas.width, y);
            ctx.stroke();
        }
        
        // ์ˆ˜์ง์„ 
        for (let i = 0; i <= 10; i++) {
            const x = (canvas.width / 10) * i;
            ctx.beginPath();
            ctx.moveTo(x, 0);
            ctx.lineTo(x, canvas.height);
            ctx.stroke();
        }
    }
    
    drawLine(ctx, canvas) {
        if (this.data.length < 2) return;
        
        const width = canvas.width;
        const height = canvas.height;
        const step = width / this.maxPoints;
        
        // ์ตœ์†Œ/์ตœ๋Œ€๊ฐ’ ์ฐพ๊ธฐ
        const values = this.data.map(d => d.value);
        const min = Math.min(...values);
        const max = Math.max(...values);
        const range = max - min || 1;
        
        // ๋ผ์ธ ๊ทธ๋ฆฌ๊ธฐ
        ctx.beginPath();
        ctx.strokeStyle = '#667eea';
        ctx.lineWidth = 2;
        ctx.lineJoin = 'round';
        ctx.lineCap = 'round';
        
        this.data.forEach((point, index) => {
            const x = index * step;
            const y = height - ((point.value - min) / range) * height;
            
            if (index === 0) {
                ctx.moveTo(x, y);
            } else {
                ctx.lineTo(x, y);
            }
        });
        
        ctx.stroke();
        
        // ์˜์—ญ ์ฑ„์šฐ๊ธฐ
        ctx.lineTo(width, height);
        ctx.lineTo(0, height);
        ctx.closePath();
        ctx.fillStyle = 'rgba(102, 126, 234, 0.1)';
        ctx.fill();
    }
}

๐Ÿš€ ๋ฏธ๋ž˜ ํŠธ๋ Œ๋“œ์™€ ๋ฐœ์ „ ๋ฐฉํ–ฅ

์‹ค์‹œ๊ฐ„ ๋ฐ์ดํ„ฐ ์‹œ๊ฐํ™” ๊ธฐ์ˆ ์€ ๊ณ„์† ์ง„ํ™”ํ•˜๊ณ  ์žˆ์–ด์š”! ์•ž์œผ๋กœ ์ฃผ๋ชฉํ•ด์•ผ ํ•  ํŠธ๋ Œ๋“œ๋“ค์„ ์‚ดํŽด๋ณผ๊นŒ์š”?

๐Ÿค– AI/ML ํ†ตํ•ฉ

๋จธ์‹ ๋Ÿฌ๋‹์„ ํ™œ์šฉํ•œ ์ด์ƒ ํƒ์ง€์™€ ์˜ˆ์ธก ์‹œ๊ฐํ™”๊ฐ€ ๋Œ€์„ธ๊ฐ€ ๋˜๊ณ  ์žˆ์–ด์š”. ์‹ค์‹œ๊ฐ„์œผ๋กœ ๋“ค์–ด์˜ค๋Š” ๋ฐ์ดํ„ฐ๋ฅผ AI๊ฐ€ ๋ถ„์„ํ•ด์„œ ๋ฏธ๋ž˜๋ฅผ ์˜ˆ์ธกํ•˜๊ณ , ๊ทธ๊ฑธ ์‹œ๊ฐํ™”ํ•˜๋Š” ๊ฑฐ์ฃ !

// TensorFlow.js๋ฅผ ํ™œ์šฉํ•œ ์‹ค์‹œ๊ฐ„ ์˜ˆ์ธก
import * as tf from '@tensorflow/tfjs';

class PredictiveChart {
    constructor() {
        this.model = null;
        this.data = [];
        this.predictions = [];
        this.sequenceLength = 10;
    }
    
    async loadModel() {
        // ์‚ฌ์ „ ํ•™์Šต๋œ ๋ชจ๋ธ ๋กœ๋“œ
        this.model = await tf.loadLayersModel('/models/timeseries/model.json');
        console.log('๋ชจ๋ธ ๋กœ๋“œ ์™„๋ฃŒ!');
    }
    
    async addDataAndPredict(value) {
        this.data.push(value);
        
        if (this.data.length > 100) {
            this.data.shift();
        }
        
        // ์ถฉ๋ถ„ํ•œ ๋ฐ์ดํ„ฐ๊ฐ€ ์Œ“์ด๋ฉด ์˜ˆ์ธก
        if (this.data.length >= this.sequenceLength) {
            const prediction = await this.predict();
            this.predictions.push(prediction);
            
            if (this.predictions.length > 20) {
                this.predictions.shift();
            }
        }
    }
    
    async predict() {
        // ์ตœ๊ทผ ๋ฐ์ดํ„ฐ๋กœ ์‹œํ€€์Šค ์ƒ์„ฑ
        const sequence = this.data.slice(-this.sequenceLength);
        
        // ์ •๊ทœํ™”
        const mean = sequence.reduce((a, b) => a + b) / sequence.length;
        const std = Math.sqrt(
            sequence.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / sequence.length
        );
        
        const normalized = sequence.map(val => (val - mean) / (std || 1));
        
        // ํ…์„œ๋กœ ๋ณ€ํ™˜
        const input = tf.tensor3d([normalized], [1, this.sequenceLength, 1]);
        
        // ์˜ˆ์ธก
        const output = this.model.predict(input);
        const prediction = await output.data();
        
        // ์—ญ์ •๊ทœํ™”
        const denormalized = prediction[0] * (std || 1) + mean;
        
        // ๋ฉ”๋ชจ๋ฆฌ ์ •๋ฆฌ
        input.dispose();
        output.dispose();
        
        return denormalized;
    }
    
    getChartData() {
        return {
            actual: this.data,
            predicted: this.predictions
        };
    }
}

๐ŸŒ WebAssembly ํ™œ์šฉ

๋Œ€์šฉ๋Ÿ‰ ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ์—๋Š” WebAssembly๊ฐ€ ๋‹ต์ด์—์š”! JavaScript๋ณด๋‹ค ํ›จ์”ฌ ๋น ๋ฅด๊ฑฐ๋“ ์š” ใ…‹ใ…‹

// Rust๋กœ ์ž‘์„ฑํ•œ ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ ๋กœ์ง์„ WASM์œผ๋กœ ์ปดํŒŒ์ผ
// rust_processor.rs
use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub struct DataProcessor {
    buffer: Vec<f64>,
    window_size: usize,
}

#[wasm_bindgen]
impl DataProcessor {
    #[wasm_bindgen(constructor)]
    pub fn new(window_size: usize) -> DataProcessor {
        DataProcessor {
            buffer: Vec::new(),
            window_size,
        }
    }
    
    pub fn add_value(&mut self, value: f64) {
        self.buffer.push(value);
        if self.buffer.len() > self.window_size {
            self.buffer.remove(0);
        }
    }
    
    pub fn calculate_statistics(&self) -> JsValue {
        if self.buffer.is_empty() {
            return JsValue::NULL;
        }
        
        let sum: f64 = self.buffer.iter().sum();
        let mean = sum / self.buffer.len() as f64;
        
        let variance: f64 = self.buffer
            .iter()
            .map(|x| (x - mean).powi(2))
            .sum::<f64>() / self.buffer.len() as f64;
        
        let std_dev = variance.sqrt();
        
        let max = self.buffer.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
        let min = self.buffer.iter().cloned().fold(f64::INFINITY, f64::min);
        
        // JavaScript ๊ฐ์ฒด๋กœ ๋ฐ˜ํ™˜
        let result = js_sys::Object::new();
        js_sys::Reflect::set(&result, &"mean".into(), &mean.into()).unwrap();
        js_sys::Reflect::set(&result, &"stdDev".into(), &std_dev.into()).unwrap();
        js_sys::Reflect::set(&result, &"max".into(), &max.into()).unwrap();
        js_sys::Reflect::set(&result, &"min".into(), &min.into()).unwrap();
        
        result.into()
    }
}
// JavaScript์—์„œ WASM ๋ชจ๋“ˆ ์‚ฌ์šฉ
import init, { DataProcessor } from './rust_processor.js';

async function setupWasmProcessor() {
    // WASM ์ดˆ๊ธฐํ™”
    await init();
    
    const processor = new DataProcessor(100);
    
    // WebSocket์œผ๋กœ ๋ฐ์ดํ„ฐ ์ˆ˜์‹ 
    socket.onmessage = function(event) {
        const data = JSON.parse(event.data);
        
        // WASM์œผ๋กœ ๊ณ ์† ์ฒ˜๋ฆฌ
        processor.add_value(data.value);
        const stats = processor.calculate_statistics();
        
        console.log('ํ†ต๊ณ„:', stats);
        updateChart(stats);
    };
}

setupWasmProcessor();

๐ŸŽฎ 3D ์‹œ๊ฐํ™”

Three.js๋ฅผ ํ™œ์šฉํ•œ 3D ์‹ค์‹œ๊ฐ„ ์‹œ๊ฐํ™”๋„ ์ ์  ์ธ๊ธฐ๋ฅผ ์–ป๊ณ  ์žˆ์–ด์š”! ํŠนํžˆ IoT ์„ผ์„œ ๋ฐ์ดํ„ฐ๋‚˜ ๋„คํŠธ์›Œํฌ ํ† ํด๋กœ์ง€ ๊ฐ™์€ ๊ฑธ ํ‘œํ˜„ํ•  ๋•Œ ์œ ์šฉํ•ด์š”.

// Three.js๋กœ 3D ์‹ค์‹œ๊ฐ„ ์‹œ๊ฐํ™”
import * as THREE from 'three';
import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls';

class Realtime3DChart {
    constructor(container) {
        this.container = container;
        this.scene = new THREE.Scene();
        this.camera = new THREE.PerspectiveCamera(
            75, 
            container.clientWidth / container.clientHeight, 
            0.1, 
            1000
        );
        
        this.renderer = new THREE.WebGLRenderer({ antialias: true });
        this.renderer.setSize(container.clientWidth, container.clientHeight);
        this.renderer.setClearColor(0xf0f0f0);
        container.appendChild(this.renderer.domElement);
        
        this.controls = new OrbitControls(this.camera, this.renderer.domElement);
        this.camera.position.set(0, 5, 10);
        this.controls.update();
        
        this.dataPoints = [];
        this.maxPoints = 50;
        
        this.setupLights();
        this.setupGrid();
        this.animate();
    }
    
    setupLights() {
        const ambientLight = new THREE.AmbientLight(0xffffff, 0.6);
        this.scene.add(ambientLight);
        
        const directionalLight = new THREE.DirectionalLight(0xffffff, 0.8);
        directionalLight.position.set(10, 10, 5);
        this.scene.add(directionalLight);
    }
    
    setupGrid() {
        const gridHelper = new THREE.GridHelper(20, 20, 0xcccccc, 0xeeeeee);
        this.scene.add(gridHelper);
    }
    
    addData(value) {
        // ์ƒˆ๋กœ์šด ๋ฐ์ดํ„ฐ ํฌ์ธํŠธ ์ƒ์„ฑ
        const geometry = new THREE.SphereGeometry(0.2, 16, 16);
        const material = new THREE.MeshPhongMaterial({
            color: this.getColorForValue(value),
            emissive: 0x072534,
            shininess: 30
        });
        
        const sphere = new THREE.Mesh(geometry, material);
        
        // ์œ„์น˜ ์„ค์ •
        const x = (this.dataPoints.length * 0.4) - 10;
        const y = value / 10; // ๊ฐ’์— ๋”ฐ๋ผ ๋†’์ด ์กฐ์ ˆ
        const z = 0;
        
        sphere.position.set(x, y, z);
        this.scene.add(sphere);
        
        this.dataPoints.push({
            mesh: sphere,
            value: value,
            timestamp: Date.now()
        });
        
        // ์˜ค๋ž˜๋œ ํฌ์ธํŠธ ์ œ๊ฑฐ
        if (this.dataPoints.length > this.maxPoints) {
            const old = this.dataPoints.shift();
            this.scene.remove(old.mesh);
            old.mesh.geometry.dispose();
            old.mesh.material.dispose();
        }
        
        // ๋ผ์ธ์œผ๋กœ ์—ฐ๊ฒฐ
        this.updateConnections();
    }
    
    updateConnections() {
        // ๊ธฐ์กด ๋ผ์ธ ์ œ๊ฑฐ
        const lines = this.scene.children.filter(child => child.type === 'Line');
        lines.forEach(line => {
            this.scene.remove(line);
            line.geometry.dispose();
            line.material.dispose();
        });
        
        // ์ƒˆ ๋ผ์ธ ์ƒ์„ฑ
        if (this.dataPoints.length < 2) return;
        
        const points = this.dataPoints.map(dp => dp.mesh.position);
        const geometry = new THREE.BufferGeometry().setFromPoints(points);
        const material = new THREE.LineBasicMaterial({ 
            color: 0x667eea,
            linewidth: 2
        });
        
        const line = new THREE.Line(geometry, material);
        this.scene.add(line);
    }
    
    getColorForValue(value) {
        // ๊ฐ’์— ๋”ฐ๋ผ ์ƒ‰์ƒ ๋ณ€๊ฒฝ
        if (value > 80) return 0xff4444; // ๋นจ๊ฐ•
        if (value > 60) return 0xffaa44; // ์ฃผํ™ฉ
        if (value > 40) return 0xffff44; // ๋…ธ๋ž‘
        return 0x44ff44; // ์ดˆ๋ก
    }
    
    animate() {
        requestAnimationFrame(() => this.animate());
        
        this.controls.update();
        this.renderer.render(this.scene, this.camera);
    }
    
    handleResize() {
        const width = this.container.clientWidth;
        const height = this.container.clientHeight;
        
        this.camera.aspect = width / height;
        this.camera.updateProjectionMatrix();
        this.renderer.setSize(width, height);
    }
}

// ์‚ฌ์šฉ ์˜ˆ์‹œ
const chart3D = new Realtime3DChart(document.getElementById('chart-container'));

socket.onmessage = function(event) {
    const data = JSON.parse(event.data);
    chart3D.addData(data.value);
};

window.addEventListener('resize', () => chart3D.handleResize());

๐Ÿ“š ๋งˆ๋ฌด๋ฆฌํ•˜๋ฉฐ

์™€... ์—ฌ๊ธฐ๊นŒ์ง€ ์ฝ์œผ์…จ๋‹ค๋ฉด ์ง„์งœ ๋Œ€๋‹จํ•˜์„ธ์š”! ๐Ÿ‘ ์‹ค์‹œ๊ฐ„ ๋ฐ์ดํ„ฐ ์‹œ๊ฐํ™”๋Š” ์ฒ˜์Œ์—” ์–ด๋ ค์›Œ ๋ณด์ด์ง€๋งŒ, ํ•˜๋‚˜์”ฉ ์ฐจ๊ทผ์ฐจ๊ทผ ๋ฐฐ์šฐ๋‹ค ๋ณด๋ฉด ์ •๋ง ์žฌ๋ฏธ์žˆ๋Š” ๋ถ„์•ผ์˜ˆ์š”.

ํ•ต์‹ฌ์„ ์ •๋ฆฌํ•˜์ž๋ฉด:

๐ŸŽฏ ์‹ค์‹œ๊ฐ„ ์‹œ๊ฐํ™” ํ•ต์‹ฌ ์š”์•ฝ

1๏ธโƒฃ ํ†ต์‹  ๋ฐฉ์‹ ์„ ํƒ - WebSocket, SSE, Polling ์ค‘ ์ƒํ™ฉ์— ๋งž๊ฒŒ
2๏ธโƒฃ ์‹œ๊ฐํ™” ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ - Chart.js(๊ฐ„๋‹จ), D3.js(์ž์œ ๋„), ECharts(์„ฑ๋Šฅ)
3๏ธโƒฃ ์„ฑ๋Šฅ ์ตœ์ ํ™” - ์ƒ˜ํ”Œ๋ง, RAF, Web Workers ํ™œ์šฉ
4๏ธโƒฃ ๋ณด์•ˆ - WSS, ์ธ์ฆ, Rate Limiting ํ•„์ˆ˜
5๏ธโƒฃ ์•ˆ์ •์„ฑ - ์žฌ์—ฐ๊ฒฐ ๋กœ์ง, ์—๋Ÿฌ ํ•ธ๋“ค๋ง, ๋ชจ๋‹ˆํ„ฐ๋ง

์‹ค๋ฌด์—์„œ๋Š” ์ด๋Ÿฐ ๊ธฐ์ˆ ๋“ค์„ ์กฐํ•ฉํ•ด์„œ ์‚ฌ์šฉํ•˜๊ฒŒ ๋ผ์š”. ์ฒ˜์Œ์—” ๊ฐ„๋‹จํ•œ ํ”„๋กœ์ ํŠธ๋ถ€ํ„ฐ ์‹œ์ž‘ํ•ด์„œ ์ ์  ๋ณต์žกํ•œ ๊ฑธ ๋งŒ๋“ค์–ด๋ณด์„ธ์š”! ๊ทธ๋ฆฌ๊ณ  ๋ง‰ํžˆ๋Š” ๋ถ€๋ถ„์ด ์žˆ์œผ๋ฉด ์žฌ๋Šฅ๋„ท์—์„œ ์ „๋ฌธ๊ฐ€์˜ ๋„์›€์„ ๋ฐ›๋Š” ๊ฒƒ๋„ ์ข‹์€ ๋ฐฉ๋ฒ•์ด์—์š” ใ…Žใ…Ž

์‹ค์‹œ๊ฐ„ ๋ฐ์ดํ„ฐ ์‹œ๊ฐํ™”๋Š” ์•ž์œผ๋กœ๋„ ๊ณ„์† ๋ฐœ์ „ํ•  ๋ถ„์•ผ์˜ˆ์š”. AI, WebAssembly, 3D ์‹œ๊ฐํ™” ๋“ฑ ์ƒˆ๋กœ์šด ๊ธฐ์ˆ ๋“ค์ด ๊ณ„์† ๋‚˜์˜ค๊ณ  ์žˆ์œผ๋‹ˆ๊นŒ์š”. ์ง€๊ธˆ ๋ฐฐ์›Œ๋‘๋ฉด ๋‚˜์ค‘์— ์ •๋ง ์œ ์šฉํ•˜๊ฒŒ ์“ธ ์ˆ˜ ์žˆ์„ ๊ฑฐ์˜ˆ์š”!

์—ฌ๋Ÿฌ๋ถ„์˜ ํ”„๋กœ์ ํŠธ์— ๋ฉ‹์ง„ ์‹ค์‹œ๊ฐ„ ์‹œ๊ฐํ™”๋ฅผ ์ถ”๊ฐ€ํ•ด๋ณด์„ธ์š”. ์‚ฌ์šฉ์ž๋“ค์ด ์™€~ ํ•˜๊ณ  ๊ฐํƒ„ํ•  ๊ฑฐ์˜ˆ์š”! ๐Ÿš€โœจ

๐Ÿ’ช ํ™”์ดํŒ…! ์—ฌ๋Ÿฌ๋ถ„๋„ ์ถฉ๋ถ„ํžˆ ํ•  ์ˆ˜ ์žˆ์–ด์š”!
๐ŸŽจ ๋ฐ์ดํ„ฐ๋ฅผ ์•„๋ฆ„๋‹ต๊ฒŒ ํ‘œํ˜„ํ•˜๋Š” ๊ฐœ๋ฐœ์ž๊ฐ€ ๋˜์„ธ์š”!

๋Œ“๊ธ€ ์ž‘์„ฑ

์ด ๊ธ€์— ๋Œ€ํ•œ ์—ฌ๋Ÿฌ๋ถ„์˜ ์ƒ๊ฐ์„ ๋“ค๋ ค์ฃผ์„ธ์š”

๋Œ“๊ธ€ 0
๋Œ“๊ธ€์„ ๋ถˆ๋Ÿฌ์˜ค๋Š” ์ค‘์ž…๋‹ˆ๋‹ค.

์•„์ง ๋Œ“๊ธ€์ด ์—†์Šต๋‹ˆ๋‹ค.