9040282911

Committed 11 May 2024 02:01AM UTC coverage: 63.355% (-0.05%) from 63.408%

Build # 9040282911

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #80 from HuolalaTech/feat/hide-logo

feat: the logo can be hidden in the left/right

Run Details

1344 of 1496 branches covered (89.84%)

Branch coverage included in aggregate %.

50 of 87 new or added lines in 2 files covered. (57.47%)

5 existing lines in 1 file now uncovered.

5352 of 9073 relevant lines covered (58.99%)

30.94 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/packages/page-spy-plugin-data-harbor/src/index.ts

import type {
  SpyMessage,
  OnInitParams,
  OnMountedParams,
  PageSpyPlugin,
  PluginOrder,
} from '@huolala-tech/page-spy-types';
import { isBrowser, isPlainObject, psLog } from 'base/src';
import { strFromU8, zlibSync, strToU8 } from 'fflate';
import type RequestItem from 'base/src/request-item';
import type { InitConfig } from 'page-spy-browser/types';
import { Harbor } from './harbor';
import { DownloadArgs, handleDownload, startDownload } from './utils/download';
import { UploadArgs, handleUpload, startUpload } from './utils/upload';
import { getDeviceId } from './utils';

type DataType = 'console' | 'network' | 'system' | 'storage' | 'rrweb-event';

export type CacheMessageItem = Pick<
  SpyMessage.MessageItem<SpyMessage.DataType, any>,
  'type' | 'data'
> & {
  timestamp: number;
};

interface DataHarborConfig {
  maximum?: number;
  caredData?: Record<DataType, boolean>;
  filename?: () => string;
  onDownload?: (data: CacheMessageItem[]) => void;
}

const minifyData = (d: any) => {
  return strFromU8(zlibSync(strToU8(JSON.stringify(d)), { level: 9 }), true);
};

const makeData = (type: SpyMessage.DataType, data: any) => {
  return {
    type,
    timestamp: Date.now(),
    data: minifyData(data),
  };
};

export default class DataHarborPlugin implements PageSpyPlugin {
  public enforce: PluginOrder = 'pre';

  public name = 'DataHarborPlugin';

  // "Harbor" is an abstraction for scheduling data actions.
  private harbor: Harbor;

  // Specify which types of data to collect.
  private caredData: Record<DataType, boolean> = {
    console: true,
    network: true,
    storage: true,
    system: true,
    'rrweb-event': true,
  };

  private apiBase: string = '';

  private $pageSpyConfig: InitConfig | null = null;

  private filename: DataHarborConfig['filename'] = () => {
    return new Date().toLocaleString();
  };

  private onDownload: DataHarborConfig['onDownload'];

  public static hasInited = false;

  public static hasMounted = false;

  constructor(config: DataHarborConfig = {}) {
    if (isPlainObject(config.caredData)) {
      this.caredData = {
        ...this.caredData,
        ...config.caredData,
      };
    }
    if (typeof config.onDownload === 'function') {
      this.onDownload = config.onDownload;
    }
    if (typeof config.filename === 'function') {
      this.filename = config.filename;
    }
    this.harbor = new Harbor({ maximum: config.maximum });
  }

  public async onInit({ socketStore, config }: OnInitParams<InitConfig>) {
    if (DataHarborPlugin.hasInited) return;
    DataHarborPlugin.hasInited = true;

    this.$pageSpyConfig = config;
    const { api, enableSSL } = config;
    if (!api) {
      psLog.warn(
        "Cannot upload log to PageSpy for miss 'api' configuration. See: ",
        config,
      );
    } else {
      const apiScheme = enableSSL ? 'https://' : 'http://';
      this.apiBase = `${apiScheme}${api}`;
    }

    socketStore.addListener('public-data', async (message) => {
      if (!this.isCaredPublicData(message)) return;

      const data = makeData(message.type, message.data);

      const ok = this.harbor.save(data);
      if (!ok) {
        psLog.warn(`[${this.name}] Save data failed`, data);
      }
    });
  }

  public onMounted({ content }: OnMountedParams) {
    if (DataHarborPlugin.hasMounted) return;
    DataHarborPlugin.hasMounted = true;

    if (isBrowser()) {
      const downloadBtn = handleDownload(this.getParams('download'));
      const uploadBtn = handleUpload(this.getParams('upload'));

      content.insertAdjacentElement('beforeend', downloadBtn);
      content.insertAdjacentElement('beforeend', uploadBtn);
    }
  }

  getParams(type: 'download'): DownloadArgs;
  getParams(type: 'upload'): UploadArgs;
  getParams(type: any) {
    if (type === 'download') {
      return {
        harbor: this.harbor,
        filename: this.filename!,
        customDownload: this.onDownload,
      };
    }
    return {
      harbor: this.harbor,
      uploadUrl: this.apiBase,
      filename: this.filename!,
      debugClient: this.$pageSpyConfig?.clientOrigin!,
      tags: {
        project: this.$pageSpyConfig?.project,
        title: this.$pageSpyConfig?.title,
        deviceId: getDeviceId(),
        userAgent: navigator.userAgent,
      },
    } as UploadArgs;
  }

  // eslint-disable-next-line consistent-return
  async onOfflineLog(type: 'download' | 'upload') {
    try {
      switch (type) {
        case 'download':
          startDownload(this.getParams('download'));
          break;
        case 'upload':
          const url = await startUpload(this.getParams('upload'));
          return url;
        default:
          break;
      }
    } catch (e: any) {
      psLog.error(e.message);
    }
  }

  onReset() {
    this.harbor.clear();
    DataHarborPlugin.hasInited = false;
    DataHarborPlugin.hasMounted = false;
    const node = document.getElementById('data-harbor-plugin-download');
    if (node) {
      node.remove();
    }
  }

  private isCaredPublicData(message: SpyMessage.MessageItem) {
    if (!message) return false;
    const { type } = message;
    switch (type) {
      case 'console':
        if (this.caredData.console) return true;
        return false;
      case 'storage':
        if (this.caredData.storage) return true;
        return false;
      case 'system':
        if (this.caredData.system) return true;
        return false;
      case 'rrweb-event':
        if (this.caredData['rrweb-event']) return true;
        return false;
      case 'network':
        const { url } = message.data as RequestItem;
        const isFetchHarborStockUrl = this.harbor.stock.includes(url);

        if (this.caredData.network && !isFetchHarborStockUrl) return true;
        return false;
      // case DEBUG_MESSAGE_TYPE.DATABASE:
      //   if (['update', 'clear', 'drop'].includes(data.action)) {
      //     if (data.database?.includes(SKIP_PUBLIC_IDB_PREFIX)) {
      //       return false;
      //     }
      //     return true;
      //   }
      //   break;
      default:
        return false;
    }
  }
}

1	import type {	×
2	SpyMessage,	×
3	OnInitParams,	×
4	OnMountedParams,	×
5	PageSpyPlugin,	×
6	PluginOrder,	×
7	} from '@huolala-tech/page-spy-types';	×
8	import { isBrowser, isPlainObject, psLog } from 'base/src';	×
9	import { strFromU8, zlibSync, strToU8 } from 'fflate';	×
10	import type RequestItem from 'base/src/request-item';	×
11	import type { InitConfig } from 'page-spy-browser/types';	×
12	import { Harbor } from './harbor';	×
13	import { DownloadArgs, handleDownload, startDownload } from './utils/download';	×
14	import { UploadArgs, handleUpload, startUpload } from './utils/upload';	×
15	import { getDeviceId } from './utils';	×
16		×
17	type DataType = 'console' \| 'network' \| 'system' \| 'storage' \| 'rrweb-event';	×
18		×
19	export type CacheMessageItem = Pick<	×
20	SpyMessage.MessageItem<SpyMessage.DataType, any>,	×
21	'type' \| 'data'	×
22	> & {	×
23	timestamp: number;	×
24	};	×
25		×
26	interface DataHarborConfig {	×
27	maximum?: number;	×
28	caredData?: Record<DataType, boolean>;	×
29	filename?: () => string;	×
30	onDownload?: (data: CacheMessageItem[]) => void;	×
31	}	×
32		×
33	const minifyData = (d: any) => {	×
34	return strFromU8(zlibSync(strToU8(JSON.stringify(d)), { level: 9 }), true);	×
35	};	×
36		×
37	const makeData = (type: SpyMessage.DataType, data: any) => {	×
38	return {	×
39	type,	×
40	timestamp: Date.now(),	×
41	data: minifyData(data),	×
42	};	×
43	};	×
44		×
45	export default class DataHarborPlugin implements PageSpyPlugin {	×
46	public enforce: PluginOrder = 'pre';	×
47		×
48	public name = 'DataHarborPlugin';	×
49		×
50	// "Harbor" is an abstraction for scheduling data actions.	×
51	private harbor: Harbor;	×
52		×
53	// Specify which types of data to collect.	×
54	private caredData: Record<DataType, boolean> = {	×
55	console: true,	×
56	network: true,	×
57	storage: true,	×
58	system: true,	×
59	'rrweb-event': true,	×
60	};	×
61		×
62	private apiBase: string = '';	×
63		×
64	private $pageSpyConfig: InitConfig \| null = null;	×
65		×
66	private filename: DataHarborConfig['filename'] = () => {	×
67	return new Date().toLocaleString();	×
68	};	×
69		×
70	private onDownload: DataHarborConfig['onDownload'];	×
71		×
72	public static hasInited = false;	×
73		×
74	public static hasMounted = false;	×
75		×
76	constructor(config: DataHarborConfig = {}) {	×
77	if (isPlainObject(config.caredData)) {	×
78	this.caredData = {	×
79	...this.caredData,	×
80	...config.caredData,	×
81	};	×
82	}	×
83	if (typeof config.onDownload === 'function') {	×
84	this.onDownload = config.onDownload;	×
85	}	×
86	if (typeof config.filename === 'function') {	×
87	this.filename = config.filename;	×
88	}	×
89	this.harbor = new Harbor({ maximum: config.maximum });	×
90	}	×
91		×
92	public async onInit({ socketStore, config }: OnInitParams<InitConfig>) {	×
93	if (DataHarborPlugin.hasInited) return;	×
94	DataHarborPlugin.hasInited = true;	×
95		×
96	this.$pageSpyConfig = config;	×
97	const { api, enableSSL } = config;	×
98	if (!api) {	×
99	psLog.warn(	×
100	"Cannot upload log to PageSpy for miss 'api' configuration. See: ",	×
101	config,	×
102	);	×
103	} else {	×
104	const apiScheme = enableSSL ? 'https://' : 'http://';	×
105	this.apiBase = `${apiScheme}${api}`;	×
106	}	×
107		×
108	socketStore.addListener('public-data', async (message) => {	×
109	if (!this.isCaredPublicData(message)) return;	×
110		×
111	const data = makeData(message.type, message.data);	×
112		×
113	const ok = this.harbor.save(data);	×
114	if (!ok) {	×
115	psLog.warn(`[${this.name}] Save data failed`, data);	×
116	}	×
117	});	×
118	}	×
119		×
120	public onMounted({ content }: OnMountedParams) {	×
121	if (DataHarborPlugin.hasMounted) return;	×
122	DataHarborPlugin.hasMounted = true;	×
123		×
124	if (isBrowser()) {	×
125	const downloadBtn = handleDownload(this.getParams('download'));	×
126	const uploadBtn = handleUpload(this.getParams('upload'));	×
127		×
128	content.insertAdjacentElement('beforeend', downloadBtn);	×
129	content.insertAdjacentElement('beforeend', uploadBtn);	×
130	}	×
131	}	×
132		×
133	getParams(type: 'download'): DownloadArgs;	×
134	getParams(type: 'upload'): UploadArgs;	×
135	getParams(type: any) {	×
136	if (type === 'download') {	×
137	return {	×
138	harbor: this.harbor,	×
139	filename: this.filename!,	×
140	customDownload: this.onDownload,	×
141	};	×
142	}	×
143	return {	×
144	harbor: this.harbor,	×
145	uploadUrl: this.apiBase,	×
146	filename: this.filename!,	×
147	debugClient: this.$pageSpyConfig?.clientOrigin!,	×
148	tags: {	×
149	project: this.$pageSpyConfig?.project,	×
150	title: this.$pageSpyConfig?.title,	×
151	deviceId: getDeviceId(),	×
152	userAgent: navigator.userAgent,	×
153	},	×
154	} as UploadArgs;	×
155	}	×
156		×
157	// eslint-disable-next-line consistent-return	×
158	async onOfflineLog(type: 'download' \| 'upload') {	×
159	try {	×
160	switch (type) {	×
161	case 'download':	×
162	startDownload(this.getParams('download'));	×
163	break;	×
164	case 'upload':	×
165	const url = await startUpload(this.getParams('upload'));	×
166	return url;	×
167	default:	×
168	break;	×
169	}	×
170	} catch (e: any) {	×
171	psLog.error(e.message);	×
172	}	×
173	}	×
174		×
175	onReset() {	×
176	this.harbor.clear();	×
177	DataHarborPlugin.hasInited = false;	×
178	DataHarborPlugin.hasMounted = false;	×
179	const node = document.getElementById('data-harbor-plugin-download');	×
180	if (node) {	×
181	node.remove();	×
182	}	×
183	}	×
184		×
185	private isCaredPublicData(message: SpyMessage.MessageItem) {	×
186	if (!message) return false;	×
187	const { type } = message;	×
188	switch (type) {	×
189	case 'console':	×
190	if (this.caredData.console) return true;	×
191	return false;	×
192	case 'storage':	×
193	if (this.caredData.storage) return true;	×
194	return false;	×
195	case 'system':	×
196	if (this.caredData.system) return true;	×
197	return false;	×
198	case 'rrweb-event':	×
199	if (this.caredData['rrweb-event']) return true;	×
200	return false;	×
201	case 'network':	×
202	const { url } = message.data as RequestItem;	×
203	const isFetchHarborStockUrl = this.harbor.stock.includes(url);	×
204		×
205	if (this.caredData.network && !isFetchHarborStockUrl) return true;	×
206	return false;	×
207	// case DEBUG_MESSAGE_TYPE.DATABASE:	×
208	// if (['update', 'clear', 'drop'].includes(data.action)) {	×
209	// if (data.database?.includes(SKIP_PUBLIC_IDB_PREFIX)) {	×
210	// return false;	×
211	// }	×
212	// return true;	×
213	// }	×
214	// break;	×
UNCOV 215	default:	×
UNCOV 216	return false;	×
UNCOV 217	}	×
UNCOV 218	}	×
UNCOV 219	}	×

HuolalaTech / page-spy / 9040282911

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous