@k-msg/analytics 0.1.1 → 0.1.3

package/dist/insights/anomaly.detector.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Anomaly Detector
+ * 이상 징후 탐지 및 분석
+ */
+import type { AggregatedMetric, InsightData, MetricData } from "../types/analytics.types";
+import { MetricType } from "../types/analytics.types";
+export interface AnomalyDetectionConfig {
+    algorithms: AnomalyAlgorithm[];
+    sensitivity: "low" | "medium" | "high";
+    minDataPoints: number;
+    confidenceThreshold: number;
+    enableSeasonalAdjustment: boolean;
+}
+export interface AnomalyAlgorithm {
+    name: string;
+    type: "statistical" | "ml" | "rule-based";
+    enabled: boolean;
+    config: Record<string, any>;
+}
+export interface Anomaly {
+    id: string;
+    metricType: MetricType;
+    timestamp: Date;
+    value: number;
+    expectedValue: number;
+    deviation: number;
+    severity: "low" | "medium" | "high" | "critical";
+    confidence: number;
+    algorithm: string;
+    dimensions: Record<string, string>;
+    context?: {
+        trend: "increasing" | "decreasing" | "stable";
+        seasonality: boolean;
+        historicalComparison: number;
+    };
+}
+export declare class AnomalyDetector {
+    private config;
+    private historicalData;
+    private seasonalPatterns;
+    private baselines;
+    private defaultConfig;
+    constructor(config?: Partial<AnomalyDetectionConfig>);
+    /**
+     * 실시간 이상 탐지
+     */
+    detectRealTimeAnomalies(metric: MetricData): Promise<Anomaly[]>;
+    /**
+     * 배치 이상 탐지
+     */
+    detectBatchAnomalies(metrics: AggregatedMetric[], timeWindow?: {
+        start: Date;
+        end: Date;
+    }): Promise<Anomaly[]>;
+    /**
+     * 트렌드 변화 탐지
+     */
+    detectTrendChanges(metrics: AggregatedMetric[], windowSize?: number): Promise<InsightData[]>;
+    /**
+     * 베이스라인 업데이트
+     */
+    updateBaselines(metrics: AggregatedMetric[]): Promise<void>;
+    private runAlgorithm;
+    private zScoreDetection;
+    private iqrDetection;
+    private isolationForestDetection;
+    private thresholdDetection;
+    private calculateSeverity;
+    private calculateTrendSeverity;
+    private getMetricKey;
+    private updateHistoricalData;
+    private groupMetricsByTypeAndDimensions;
+    private adjustForSeasonality;
+    private calculateTrend;
+    private detectTrend;
+    private getSensitivityThreshold;
+    private calculateIsolationThreshold;
+    private calculateIsolationScore;
+    private deduplicateAndRankAnomalies;
+    private generateTrendRecommendations;
+}

package/dist/insights/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Insights - 인사이트 생성 컴포넌트들
+ */
+export { type Anomaly, type AnomalyAlgorithm, type AnomalyDetectionConfig, AnomalyDetector, } from "./anomaly.detector";
+export { type Recommendation, type RecommendationConfig, RecommendationEngine, type RecommendationRule, } from "./recommendation.engine";

package/dist/insights/recommendation.engine.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Recommendation Engine
+ * 데이터 기반 추천 시스템
+ */
+import type { AggregatedMetric } from "../types/analytics.types";
+import { MetricType } from "../types/analytics.types";
+export interface RecommendationConfig {
+    rules: RecommendationRule[];
+    enableMachineLearning: boolean;
+    confidenceThreshold: number;
+    maxRecommendations: number;
+    categories: RecommendationCategory[];
+}
+export interface RecommendationRule {
+    id: string;
+    name: string;
+    category: string;
+    priority: number;
+    conditions: RuleCondition[];
+    actions: RecommendationAction[];
+    enabled: boolean;
+}
+export interface RuleCondition {
+    metric: MetricType;
+    operator: "gt" | "lt" | "eq" | "gte" | "lte" | "between" | "trend";
+    value: number | [number, number];
+    timeWindow?: string;
+    dimensions?: Record<string, string>;
+}
+export interface RecommendationAction {
+    type: "optimization" | "cost-saving" | "performance" | "reliability" | "security";
+    title: string;
+    description: string;
+    impact: "low" | "medium" | "high";
+    effort: "low" | "medium" | "high";
+    steps: string[];
+    estimatedBenefit?: {
+        metric: MetricType;
+        improvement: number;
+        unit: string;
+    };
+}
+export interface Recommendation {
+    id: string;
+    category: string;
+    priority: number;
+    title: string;
+    description: string;
+    rationale: string;
+    actions: RecommendationAction[];
+    confidence: number;
+    impact: "low" | "medium" | "high";
+    effort: "low" | "medium" | "high";
+    createdAt: Date;
+    validUntil?: Date;
+    metadata: {
+        ruleIds: string[];
+        triggeredBy: {
+            metrics: {
+                type: MetricType;
+                value: number;
+                timestamp: Date;
+            }[];
+            conditions: string[];
+        };
+        estimatedROI?: number;
+    };
+}
+export interface RecommendationCategory {
+    id: string;
+    name: string;
+    description: string;
+    weight: number;
+}
+export declare class RecommendationEngine {
+    private config;
+    private recommendations;
+    private ruleExecutionHistory;
+    private defaultConfig;
+    constructor(config?: Partial<RecommendationConfig>);
+    /**
+     * 메트릭 기반 추천 생성
+     */
+    generateRecommendations(metrics: AggregatedMetric[]): Promise<Recommendation[]>;
+    /**
+     * 특정 카테고리 추천 조회
+     */
+    getRecommendationsByCategory(category: string): Recommendation[];
+    /**
+     * 추천 실행 상태 업데이트
+     */
+    markRecommendationAsImplemented(recommendationId: string): boolean;
+    /**
+     * 추천 무시
+     */
+    dismissRecommendation(recommendationId: string, reason?: string): boolean;
+    /**
+     * 추천 통계
+     */
+    getRecommendationStats(): {
+        total: number;
+        byCategory: Record<string, number>;
+        byImpact: Record<string, number>;
+        byPriority: Record<string, number>;
+    };
+    private generateRuleBasedRecommendations;
+    private generatePatternBasedRecommendations;
+    private generateComparisonBasedRecommendations;
+    private generateMLBasedRecommendations;
+    private evaluateRuleConditions;
+    private evaluateCondition;
+    private createRecommendationFromRule;
+    private analyzeTimePatterns;
+    private generateTimeBasedRecommendations;
+    private analyzeChannelPatterns;
+    private generateChannelBasedRecommendations;
+    private analyzeErrorPatterns;
+    private generateErrorBasedRecommendations;
+    private compareProviderPerformance;
+    private generateProviderRecommendations;
+    private compareChannelEfficiency;
+    private generateChannelEfficiencyRecommendations;
+    private generateCapacityRecommendations;
+    private calculateRuleConfidence;
+    private calculateAggregateImpact;
+    private calculateAggregateEffort;
+    private generateRationale;
+    private recordRuleExecution;
+    private deduplicateAndPrioritize;
+    private initializeDefaultRules;
+}

package/dist/reports/dashboard.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Dashboard Report Generator
+ * 실시간 대시보드 데이터 생성
+ */
+import type { AggregatedMetric, AnalyticsQuery, InsightData } from "../types/analytics.types";
+export interface DashboardConfig {
+    refreshInterval: number;
+    timeRange: {
+        default: string;
+        options: string[];
+    };
+    widgets: DashboardWidget[];
+    filters: DashboardFilter[];
+}
+export interface DashboardWidget {
+    id: string;
+    type: "metric" | "chart" | "table" | "gauge" | "heatmap" | "trend";
+    title: string;
+    description?: string;
+    position: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    query: AnalyticsQuery;
+    visualization: VisualizationConfig;
+    refreshInterval?: number;
+}
+export interface VisualizationConfig {
+    chartType?: "line" | "bar" | "pie" | "area" | "scatter";
+    aggregation?: "sum" | "avg" | "min" | "max" | "count";
+    groupBy?: string[];
+    colors?: string[];
+    yAxis?: {
+        min?: number;
+        max?: number;
+        label?: string;
+    };
+    xAxis?: {
+        label?: string;
+    };
+    showLegend?: boolean;
+    showGrid?: boolean;
+}
+export interface DashboardFilter {
+    id: string;
+    name: string;
+    type: "select" | "date" | "range" | "multi-select";
+    field: string;
+    options?: Array<{
+        value: string;
+        label: string;
+    }>;
+    defaultValue?: any;
+}
+export interface DashboardData {
+    timestamp: Date;
+    timeRange: {
+        start: Date;
+        end: Date;
+    };
+    kpis: KPIData[];
+    widgets: WidgetData[];
+    insights: InsightData[];
+    filters: Record<string, any>;
+}
+export interface KPIData {
+    id: string;
+    name: string;
+    value: number;
+    previousValue?: number;
+    change?: number;
+    changePercent?: number;
+    trend: "up" | "down" | "stable";
+    unit?: string;
+    target?: number;
+    status: "good" | "warning" | "critical";
+}
+export interface WidgetData {
+    id: string;
+    title: string;
+    type: string;
+    data: any;
+    lastUpdated: Date;
+    error?: string;
+}
+export declare class DashboardGenerator {
+    private config;
+    private dataCache;
+    private defaultConfig;
+    constructor(config?: Partial<DashboardConfig>);
+    /**
+     * 대시보드 데이터 생성
+     */
+    generateDashboard(timeRange: {
+        start: Date;
+        end: Date;
+    }, filters?: Record<string, any>, metrics?: AggregatedMetric[]): Promise<DashboardData>;
+    /**
+     * 실시간 대시보드 스트림
+     */
+    streamDashboard(timeRange: {
+        start: Date;
+        end: Date;
+    }, filters?: Record<string, any>): AsyncGenerator<DashboardData>;
+    /**
+     * 특정 위젯 데이터 업데이트
+     */
+    updateWidget(widgetId: string, metrics: AggregatedMetric[], timeRange: {
+        start: Date;
+        end: Date;
+    }, filters?: Record<string, any>): Promise<WidgetData | null>;
+    /**
+     * 대시보드 구성 업데이트
+     */
+    updateConfig(config: Partial<DashboardConfig>): void;
+    /**
+     * 위젯 추가
+     */
+    addWidget(widget: DashboardWidget): void;
+    /**
+     * 위젯 제거
+     */
+    removeWidget(widgetId: string): boolean;
+    private calculateKPIs;
+    private generateWidgetData;
+    private generateSingleWidgetData;
+    private generateMetricWidgetData;
+    private generateChartWidgetData;
+    private generateGroupedChartData;
+    private generateTableWidgetData;
+    private generateGaugeWidgetData;
+    private generateHeatmapWidgetData;
+    private generateTrendWidgetData;
+    private filterMetrics;
+    private applyQueryFilters;
+    private calculatePreviousPeriodValue;
+    private getAggregatedValue;
+    private formatValue;
+    private getDefaultColor;
+    private initializeDefaultWidgets;
+}

package/dist/reports/export.manager.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Export Manager
+ * 다양한 형식으로 데이터 내보내기
+ */
+import type { AggregatedMetric, AnalyticsReport, InsightData } from "../types/analytics.types";
+export interface ExportConfig {
+    formats: ExportFormat[];
+    maxFileSize: number;
+    compressionEnabled: boolean;
+    watermark?: {
+        text: string;
+        position: "top" | "bottom";
+    };
+    scheduling?: {
+        enabled: boolean;
+        cron: string;
+        recipients: string[];
+    };
+}
+export interface ExportFormat {
+    type: "csv" | "excel" | "pdf" | "json" | "xml";
+    options?: Record<string, any>;
+    template?: string;
+}
+export interface ExportResult {
+    id: string;
+    format: string;
+    fileName: string;
+    filePath: string;
+    fileSize: number;
+    createdAt: Date;
+    downloadUrl?: string;
+    expiresAt?: Date;
+}
+export interface CSVExportOptions {
+    delimiter: string;
+    includeHeaders: boolean;
+    dateFormat: string;
+    encoding: "utf-8" | "utf-16";
+}
+export interface PDFExportOptions {
+    orientation: "portrait" | "landscape";
+    pageSize: "A4" | "A3" | "letter";
+    includeCharts: boolean;
+    template: "standard" | "executive" | "detailed";
+}
+export interface ExcelExportOptions {
+    worksheets: Array<{
+        name: string;
+        data: any[];
+        charts?: Array<{
+            type: "line" | "bar" | "pie";
+            title: string;
+            range: string;
+        }>;
+    }>;
+    formatting: {
+        autoFilter: boolean;
+        freezeFirstRow: boolean;
+        columnWidths: "auto" | number[];
+    };
+}
+export declare class ExportManager {
+    private config;
+    private exports;
+    private exportQueue;
+    private defaultConfig;
+    constructor(config?: Partial<ExportConfig>);
+    /**
+     * 분석 보고서 내보내기
+     */
+    exportReport(report: AnalyticsReport, format: ExportFormat, options?: any): Promise<ExportResult>;
+    /**
+     * 메트릭 데이터 내보내기
+     */
+    exportMetrics(metrics: AggregatedMetric[], format: ExportFormat, options?: any): Promise<ExportResult>;
+    /**
+     * 인사이트 데이터 내보내기
+     */
+    exportInsights(insights: InsightData[], format: ExportFormat, options?: any): Promise<ExportResult>;
+    /**
+     * 내보내기 상태 조회
+     */
+    getExportStatus(exportId: string): ExportResult | null;
+    /**
+     * 내보내기 목록 조회
+     */
+    listExports(limit?: number): ExportResult[];
+    /**
+     * 내보내기 삭제
+     */
+    deleteExport(exportId: string): boolean;
+    private exportToCSV;
+    private exportToExcel;
+    private exportToPDF;
+    private exportToJSON;
+    private exportToXML;
+    private exportMetricsToCSV;
+    private exportMetricsToJSON;
+    private exportInsightsToCSV;
+    private exportInsightsToJSON;
+    private exportInsightsToPDF;
+    private generateExportId;
+}

package/dist/reports/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Reports - 보고서 생성 컴포넌트들
+ */
+export { type DashboardConfig, type DashboardData, DashboardGenerator, type DashboardWidget, type KPIData, type WidgetData, } from "./dashboard";
+export { type ExportConfig, type ExportFormat, ExportManager, type ExportResult, } from "./export.manager";

package/dist/services/analytics.service.d.ts

@@ -0,0 +1,66 @@
+import type { AggregatedMetric, AnalyticsConfig, AnalyticsQuery, AnalyticsResult, InsightData, MetricData, MetricType } from "../types/analytics.types";
+export declare class AnalyticsService {
+    private config;
+    private metricsCollector;
+    private reportGenerator;
+    private insightEngine;
+    private metrics;
+    private aggregatedMetrics;
+    constructor(config: AnalyticsConfig);
+    /**
+     * 메트릭 데이터 수집
+     */
+    collectMetric(metric: MetricData): Promise<void>;
+    /**
+     * 분석 쿼리 실행
+     */
+    query(query: AnalyticsQuery): Promise<AnalyticsResult>;
+    /**
+     * 실시간 메트릭 스트림
+     */
+    streamMetrics(types: MetricType[]): AsyncGenerator<MetricData>;
+    /**
+     * 대시보드 데이터 조회
+     */
+    getDashboardData(timeRange: {
+        start: Date;
+        end: Date;
+    }): Promise<{
+        timeRange: {
+            start: Date;
+            end: Date;
+        };
+        kpis: {
+            totalMessages: number;
+            deliveryRate: number;
+            errorRate: number;
+            clickRate: number;
+        };
+        metrics: AggregatedMetric[];
+        insights: InsightData[] | undefined;
+        trends: {};
+    }>;
+    /**
+     * 이상 탐지
+     */
+    detectAnomalies(metricType: MetricType, timeRange: {
+        start: Date;
+        end: Date;
+    }): Promise<InsightData[]>;
+    private processRealTimeMetric;
+    private validateQuery;
+    private executeQuery;
+    private performAggregation;
+    private generateInsights;
+    private getOptimalInterval;
+    private calculateKPIs;
+    private calculateTrends;
+    private sumMetrics;
+    private calculateRate;
+    private generateCacheKey;
+    private startAggregationTasks;
+    private scheduleAggregation;
+    private getScheduleInterval;
+    private runAggregation;
+    private notifyAnomalies;
+}

package/dist/services/insight.engine.d.ts

@@ -0,0 +1,44 @@
+import type { AggregatedMetric, AnalyticsConfig, AnalyticsQuery, InsightData, MetricData } from "../types/analytics.types";
+import { MetricType } from "../types/analytics.types";
+export declare class InsightEngine {
+    private config;
+    private anomalyThresholds;
+    private historicalData;
+    constructor(config: AnalyticsConfig);
+    /**
+     * 실시간 이상 탐지
+     */
+    detectRealTimeAnomalies(metric: MetricData): Promise<InsightData[]>;
+    /**
+     * 시계열 이상 탐지
+     */
+    detectAnomalies(metricType: MetricType, timeRange: {
+        start: Date;
+        end: Date;
+    }): Promise<InsightData[]>;
+    /**
+     * 인사이트 생성
+     */
+    generateInsights(query: AnalyticsQuery, data: AggregatedMetric[]): Promise<InsightData[]>;
+    /**
+     * 트렌드 예측
+     */
+    predictTrends(metricType: MetricType, forecastDays: number): Promise<{
+        date: Date;
+        predicted: number;
+        confidence: number;
+    }[]>;
+    private initializeBaselines;
+    private detectTrendChange;
+    private detectSeasonalAnomalies;
+    private detectPatternAnomalies;
+    private detectThresholdAnomalies;
+    private generatePerformanceInsights;
+    private generateTrendInsights;
+    private generateComparisonInsights;
+    private generateRecommendationInsights;
+    private calculateSeverity;
+    private calculateConfidence;
+    private generateRecommendations;
+    private calculateTrend;
+}

package/dist/services/metrics.collector.d.ts

@@ -0,0 +1,58 @@
+import type { AnalyticsConfig, MetricData, MetricType } from "../types/analytics.types";
+export declare class MetricsCollector {
+    private config;
+    private buffer;
+    private batchSize;
+    private flushInterval;
+    private storage;
+    constructor(config: AnalyticsConfig);
+    /**
+     * 메트릭 수집
+     */
+    collect(metric: MetricData): Promise<void>;
+    /**
+     * 여러 메트릭 일괄 수집
+     */
+    collectBatch(metrics: MetricData[]): Promise<void>;
+    /**
+     * 최근 메트릭 조회
+     */
+    getRecentMetrics(types: MetricType[], durationMs: number): Promise<MetricData[]>;
+    /**
+     * 메트릭 통계 조회
+     */
+    getMetricStats(type: MetricType, timeRange: {
+        start: Date;
+        end: Date;
+    }): Promise<{
+        count: number;
+        sum: number;
+        avg: number;
+        min: number;
+        max: number;
+    }>;
+    /**
+     * 메트릭 카운터 증가
+     */
+    incrementCounter(type: MetricType, dimensions: Record<string, string>, value?: number): Promise<void>;
+    /**
+     * 메트릭 게이지 값 설정
+     */
+    setGauge(type: MetricType, dimensions: Record<string, string>, value: number): Promise<void>;
+    /**
+     * 메트릭 히스토그램 기록
+     */
+    recordHistogram(type: MetricType, dimensions: Record<string, string>, value: number): Promise<void>;
+    /**
+     * 메트릭 버퍼 플러시
+     */
+    flush(): Promise<void>;
+    /**
+     * 메트릭 정리 (보존 기간 초과)
+     */
+    cleanup(): Promise<void>;
+    private validateMetric;
+    private persistMetrics;
+    private startBatchProcessor;
+    private generateMetricId;
+}

package/dist/services/report.generator.d.ts

@@ -0,0 +1,61 @@
+import type { AnalyticsConfig, AnalyticsReport } from "../types/analytics.types";
+import { MetricType } from "../types/analytics.types";
+export declare class ReportGenerator {
+    private config;
+    constructor(config: AnalyticsConfig);
+    /**
+     * 일일 요약 보고서 생성
+     */
+    generateDailySummary(date: Date): Promise<AnalyticsReport>;
+    /**
+     * 주간 보고서 생성
+     */
+    generateWeeklyReport(weekStartDate: Date): Promise<AnalyticsReport>;
+    /**
+     * 월간 보고서 생성
+     */
+    generateMonthlyReport(year: number, month: number): Promise<AnalyticsReport>;
+    /**
+     * 프로바이더별 성능 보고서
+     */
+    generateProviderReport(providerId: string, dateRange: {
+        start: Date;
+        end: Date;
+    }): Promise<AnalyticsReport>;
+    /**
+     * 템플릿 사용량 보고서
+     */
+    generateTemplateUsageReport(dateRange: {
+        start: Date;
+        end: Date;
+    }): Promise<AnalyticsReport>;
+    /**
+     * 커스텀 보고서 생성
+     */
+    generateCustomReport(name: string, dateRange: {
+        start: Date;
+        end: Date;
+    }, filters: Record<string, any>, metricTypes: MetricType[]): Promise<AnalyticsReport>;
+    /**
+     * 보고서를 CSV 형식으로 내보내기
+     */
+    exportToCSV(report: AnalyticsReport): Promise<string>;
+    /**
+     * 보고서를 JSON 형식으로 내보내기
+     */
+    exportToJSON(report: AnalyticsReport): Promise<string>;
+    private generateReport;
+    private calculateDailyMetrics;
+    private calculateWeeklyMetrics;
+    private calculateMonthlyMetrics;
+    private calculateProviderMetrics;
+    private calculateTemplateMetrics;
+    private calculateCustomMetrics;
+    private getMetricValue;
+    private getProviderPerformance;
+    private getTemplateUsage;
+    private calculateChange;
+    private calculateTrend;
+    private getMetricPriority;
+    private validateReport;
+}