KR20210144287A - Method for measuring performance of computing device - Google Patents

Abstract

A method for measuring performance and a method for analyzing a log of a computing device are provided. An access log of the computing device to be measured is obtained by a client device, and the access log is read and analyzed in a browser running on the client device. The client device automatically generates a test script based on the access log analysis result, and tests the performance of a target computing device using the same.

Description

MEASURING MEASURING PERFORMANCE OF COMPUTING DEVICE

The present invention relates to a method for measuring the performance of a computing device. More particularly, it relates to a method of providing a solution supporting all processes related to performance measurement of a computing device.

The process of measuring the performance of a computing device such as a web server consists of steps such as designing a performance measurement scenario through access log analysis, writing a script for load testing and performing tests, resetting the server configuration, and providing performance test results.

However, in conventional methods for measuring the performance of a computing device, all of the above steps must be performed through a separate tool or application. For example, it reads and analyzes the access log of the web server through Apache Log Viewer, writes and executes a load script through Loadrunner or Apache JMeter based on the analysis result, and adjusts various settings of the server by directly accessing the web server. In addition, performance measurement results such as web server performance index report must be viewed using a separate tool. In other words, a unified solution that provides the entire process of measuring the performance of a computing device is not provided.

In addition, since the access log analysis process and load script creation are provided through separate tools/applications, the access log analysis result and load script generation cannot be properly linked. For example, a function that automatically generates an appropriate load script based on the analysis result of the access log is not provided.

Similarly, a function for automatically adjusting various settings of a target computing device based on a load script test result is also not provided.

Accordingly, there is a need to provide a unified solution that efficiently connects and provides the entire process of measuring the performance of a computing device.

On the other hand, in the process of analyzing the access log of the web server, etc., after the log is downloaded from the server where the access log is generated to the client device, the access log is uploaded again to the server for analysis, and log analysis is performed on the server for analysis. it is common In general, since the amount of access log data is very large and the number of files is large, considerable network bandwidth is wasted in the process of transmitting the access log between devices several times. Also, storing access logs that should be safely stored in multiple devices may cause security issues.

Accordingly, there is a need to provide a method for conveniently analyzing the access log locally without transmitting the access log to multiple devices on the network.

Korean Patent Registration No. 10-1553923 (2015.09.11. Announcement)

A technical problem to be solved through some embodiments of the present invention is to provide a method for efficiently linking and providing a process of measuring the performance of a computing device.

Another technical problem to be solved through some embodiments of the present invention is to provide a method for analyzing a log of a computing device in a local device without transmitting the log of a computing device to various devices on a network.

Another technical problem to be solved through some embodiments of the present invention is to provide a method for rapidly analyzing a large number of log files in parallel on a browser of a local device.

The technical problems of the present invention are not limited to the technical problems mentioned above, and other technical problems not mentioned will be clearly understood by those skilled in the art from the following description.

A log analysis method according to an embodiment of the present invention for solving the above technical problem includes the steps of: obtaining a plurality of log files; and determining a chunk size, which is a unit for reading data from each of the plurality of files; and reading the log from the plurality of files in the chunk unit, reading at least some of the plurality of files in parallel, and storing the log in a data structure.

In an embodiment, determining the chunk size may include determining the chunk size based on a maximum available memory size.

In an embodiment, the determining of the chunk size may include determining the chunk size based on a value obtained by dividing the maximum available memory size by the number of the plurality of log files.

In an embodiment, the chunk size may be determined to be 20 MB or less.

In one embodiment, when the maximum available memory size is 1 GB, the chunk size is 20 MB when the number of log files is 1 or more and 50 or less, and when the number of log files is 51 or more and 100 or less, the chunk size is 10 MB, and , when the number of log files is 101 or more and 200 or less, the chunk size may be 5 MB, and when the number of log files is 201 or more, the chunk size may be 1 MB.

In an embodiment, the storing of the log in the data structure may include deep copying each line of the log read in chunk units and storing the deep copy in the data structure.

In one embodiment, the deep copying of each line and storing it in the data structure includes: obtaining a first JavaScript object in which one line of the log is stored; and converting the first JavaScript object to a JSON string. and converting the JSON string into a second JavaScript object.

In an embodiment, the converting to the JSON string may include calling a JSON.stringify function.

In an embodiment, converting the JSON string into the second JavaScript object may include calling a JSON.parse function.

In an embodiment, each step included in the method of analyzing the log may be performed by a browser running on the computing device.

In an embodiment, each step included in the method of analyzing the log may be performed by the computing device without communication with an external device.

A method for measuring performance of a computing device according to an embodiment of the present invention for solving the above technical problem includes the steps of analyzing an access log of a target computing device, and automatically generating a test script based on the access log analysis result and executing the test script to test the performance of the target computing device, and displaying the test execution result. The analyzing of the access log may include: obtaining a plurality of access log files of the target computing device; determining a chunk size that is a unit for reading data from each of the plurality of files; The method may include reading the access log from files in the chunk unit, reading at least some of the plurality of files in parallel, and storing the access log in a data structure.

A computer-readable non-transitory recording medium according to an embodiment of the present invention for solving the above technical problem includes the steps of acquiring a plurality of log files, and a chunk size as a unit for reading data from each of the plurality of files determining , reading the log from the plurality of files in the chunk unit, reading at least some of the plurality of files in parallel, and storing the log in a data structure A computer program for causing a computer to perform a method comprising a computer program is stored.

1 is a diagram for explaining a method of measuring performance of a computing device according to an embodiment of the present invention.
FIG. 2 is a flowchart of a method for measuring performance of a computing device described with reference to FIG. 1 .
3 and 4 are diagrams for explaining an access log analysis method according to another embodiment of the present invention.
5 is a flowchart of an access log analysis method described with reference to FIGS. 3 and 4 .
6 to 9B are diagrams for explaining in more detail some steps of the access log analysis method described with reference to FIG. 5 .
10 is a diagram for describing an exemplary computing device capable of implementing an object arrangement determining apparatus according to some embodiments of the present invention.

Hereinafter, preferred embodiments of the present invention will be described in detail with reference to the accompanying drawings. Advantages and features of the present invention and methods of achieving them will become apparent with reference to the embodiments described below in detail in conjunction with the accompanying drawings. However, the technical spirit of the present invention is not limited to the following embodiments, but may be implemented in various different forms, and only the following embodiments complete the technical spirit of the present invention, and in the technical field to which the present invention belongs It is provided to fully inform those of ordinary skill in the art of the scope of the present invention, and the technical spirit of the present invention is only defined by the scope of the claims.

In adding reference numerals to the components of each drawing, it should be noted that the same components are given the same reference numerals as much as possible even though they are indicated on different drawings. In addition, in describing the present invention, if it is determined that a detailed description of a related known configuration or function may obscure the gist of the present invention, the detailed description thereof will be omitted.

Unless otherwise defined, all terms (including technical and scientific terms) used herein may be used with the meaning commonly understood by those of ordinary skill in the art to which the present invention belongs. In addition, terms defined in a commonly used dictionary are not to be interpreted ideally or excessively unless clearly defined in particular. The terminology used herein is for the purpose of describing the embodiments and is not intended to limit the present invention. As used herein, the singular also includes the plural unless specifically stated otherwise in the phrase.

In addition, in describing the components of the present invention, terms such as first, second, A, B, (a), (b), etc. may be used. These terms are only for distinguishing the components from other components, and the essence, order, or order of the components are not limited by the terms. When a component is described as being “connected”, “coupled” or “connected” to another component, the component may be directly connected or connected to the other component, but another component is between each component. It should be understood that elements may be “connected,” “coupled,” or “connected.”

As used herein, “comprises” and/or “comprising” refers to the presence of one or more other components, steps, operations and/or elements mentioned. or addition is not excluded.

Hereinafter, some embodiments of the present invention will be described in detail with reference to the accompanying drawings.

1 is a diagram for explaining a method of measuring performance of a computing device according to an embodiment of the present invention. Referring to FIG. 1 , a process of measuring the performance of a computing device 3 such as a web server is performed through interaction with a client device 1 (eg, a user's local computer). Although not shown in FIG. 1 , a separate analysis server may be used in addition to the client device 1 in the performance measurement process of the computing device 3 . The user downloads the access log files generated by the computing device 3 from the performance measurement target computing device 3 to the client device 1, analyzes the log on the client device 1 or on the server for analysis, and performs target computing Design a performance measurement test scenario of the device 3 . The performance measurement test scenario includes a test script that generates a load on the target computing device 3 , such as a service request for the target computing device 3 . According to the performance measurement test scenario, the client device 1 or other agent devices under the control of the client device 1 apply a load to the target computing device 3 according to the test script to execute the test. When the test on the target computing device 3 is completed, the test result is provided to the user's client device 1 .

FIG. 2 is a flowchart illustrating a method of measuring performance of the computing device described with reference to FIG. 1 .

Each step of the performance measurement method shown in FIG. 2 may be performed by, for example, a computing device such as the client device 1 . In other words, each step of the performance measurement method may be implemented as one or more instructions executed by a processor of a computing device. All steps included in the performance measurement method may be executed by one physical computing device, but the first steps of the method are performed by a first computing device, and the second steps of the method are performed by a second computing device may be performed by Hereinafter, it is assumed that each step of the performance measurement method is performed by the client device 1 to continue the description. However, for convenience of description, the description of the operating subject of each step included in the performance measurement method may be omitted.

In the performance measurement method according to the present embodiment, first, an access log generated in the target computing device 3 is acquired for designing a performance measurement test scenario. For example, access log files generated and accumulated in the target computing device 3 during the period of interest are downloaded to the client device 1 .

In step S10, the access log files of the target computing device 3 are loaded, and contents of the access log files are analyzed.

In step S20 , a test scenario of the target computing device 3 is designed based on the analysis result of the access files. Specifically, the test scenario includes a test script that generates a load on the target computing device 3 . Based on the analysis result of the access files, an appropriate test script may be automatically generated.

In step S30 , the test script generated in step S20 is executed, thereby performing a test on the target computing device 3 . The test script is a script that generates various loads on the target computing device 3 , such as network access to the target computing device 3 , web service request, and DB inquiry. The test script may be executed by the client device 1 and/or a plurality of agent devices under the control of the client device 1 .

In step S30, while the test is performed, the state of the target computing device 3 is monitored and recorded. The state of the target computing device 3 may include a resource utilization rate of the target computing device 3 , network traffic per unit time, and the number of storage device I/O counts. The state of the target computing device 3 may be monitored and recorded by the target computing device 3 or a separate monitoring device communicatively connected to the target computing device 3 .

In step S40 , the result of the performance test for the target computing device 3 is provided. The performance test result may include at least a part of the state of the target computing device 3 monitored while the test is performed and performance indicators analyzed based thereon. The test result data generated by the target computing device 3 may be transmitted to the client device 1 or displayed to the user through the display of the client device 1 .

So far, a process of measuring the performance of the target computing device 3 through the interaction between the client device 1 and the target computing device 3 according to an embodiment of the present invention will be described with reference to FIGS. 1 and 2 . did. Hereinafter, the log analysis step ( S10 ), which is a part of the process of measuring the performance of the target computing device 3 , will be described in more detail with reference to FIGS. 3 to 9B . Hereinafter, a method of analyzing an access log has been exemplarily described for convenience of description, but it will be understood that the log analysis method according to the present invention can be applied to other types of log analysis.

3 and 4 are diagrams for explaining an access log analysis method according to another embodiment of the present invention.

Referring to FIG. 3 , the access log analysis method according to the present embodiment may be implemented as a program executed in the browser 11 of the client device 1 , and may be performed on the browser 11 . The access log analysis method according to the present embodiment may be performed by the browser 11 without communication with an external device other than the client device 1 .

In the present embodiment, the access log files 31 to be analyzed are accessed by the browser 11 . Specifically, the access log files 31 are opened by the file reader module 111 of the browser 11 . A unit in which the file reader module 111 actually reads data included in the log files 31 is referred to as a chunk in this specification. The file reader module 111 reads the log file 31 in units of chunk size and processes log data in units of lines. When processing for all lines included in one chunk is completed, the file reader module 111 reads the next chunk from the log file 31 and continues processing log data in line units.

Log data of each line unit is processed by the analysis module 113 of the browser 11 . The analysis module 113 of the browser 11 extracts and stores the analysis data from the log data in units of lines. Analysis data extracted from log data, for example, the number of transactions per second (TPS), the number of concurrent users (Concurrent Users), the response time (Response Time), and the like, are well known to those skilled in the art in the prior art. It may include a variety of known items.

The analysis data may then be provided to the viewer module 115 of the browser 11 and displayed to the user.

4 is a diagram for explaining the configuration of log data processed by the analysis module 113 of the browser 11 in more detail. Referring to FIG. 4 , each line of log data includes fields such as the time the access occurred, the IP address of the client, the address requested by the client and the request method, the request processing result code, the time taken to process the request, etc. can do. The information may be stored in each line of the log in text form. When each line of log data is divided into fields by a separator, information of each field can be appropriately processed. Information such as TPS, number of simultaneous users, and response time is extracted from the information included in the log data, and may be stored separately according to an appropriate method.

5 is a flowchart of an access log analysis method described with reference to FIGS. 3 and 4 . The access log analysis method illustrated in FIG. 5 may be performed as a part of the computing device performance measurement method described with reference to FIG. 2 . Similar to the performance measurement method described with reference to FIG. 2 , each step of the access log analysis method illustrated in FIG. 5 may be performed by, for example, a computing device such as the client device 1 . In other words, each step of the access log analysis method may be implemented as one or more instructions executed by a processor of a computing device, and all steps included in the access log analysis method are performed by one or more physical computing devices. can be implemented by Hereinafter, it is assumed that each step of the access log analysis method is performed by the client device 1 to continue the description.

Referring to FIG. 5 , the access log analysis method according to the present embodiment includes the steps of obtaining a plurality of access log files ( S100 ), determining a chunk size from which the log files are to be read ( S200 ), and a plurality of access log files It includes a step of reading the access log in chunks from the data in parallel (S300), and storing the access log in a data structure (S400).

First, in step S100, a plurality of access log files generated and accumulated in the target computing device 3 during the log analysis target period are obtained. The plurality of access log files may be obtained by being downloaded from the target computing device 3 to the client device 1 through a network. The access log files typically have a very large size of several gigabytes or more. Also, although it varies depending on the log analysis target period, the number of access log files generated and accumulated by a server providing a commercial service is generally very large, and the number of access log files may exceed several hundred.

In step S200, a chunk size from which log files are to be read is determined. As mentioned above, log files generally have a size of several gigabytes or more. Therefore, in the client device 1 having limited system resources, it is often difficult to read and process one log file as a whole into memory at a time. If the log file is analyzed on the web browser 11 , the size of chunk data that can be read from the log files at once is further limited due to the limitation of the memory size available in the web browser 11 . On the other hand, if one log file is read into the memory in a unit that is too small, for example, in units of one line, an excessive number of file I/O occurs, increasing the overall time required. Therefore, it is important to determine an appropriate chunk size, ie, a read unit, in consideration of the log file to be analyzed.

In determining the chunk size, the maximum available memory size is considered. Specifically, the size of the maximum available memory in the client device 1 on which the access log analysis method according to the present embodiment is performed is considered. The maximum available memory size may be the maximum value of the physical memory size available in the client device 1, but the maximum value of the memory size available in the operating system of the client device 1 or the application program ( For example, it may be the maximum amount of memory available in a web browser).

Also, in determining the chunk size, the number of access log files to be read simultaneously and processed in parallel is considered. As described above, the number of access log files generated and accumulated in the server providing commercial services often exceeds several hundred, and in order to efficiently utilize the processor and reduce processing time, a plurality of access log files It may be desirable to process in parallel at the same time. When a plurality of access log files are simultaneously processed in parallel, available memory resources must be distributed for processing of each file processed in parallel. For example, when the maximum available memory size is 1 GB, 1 GB of memory may be used for processing each log file by dividing the access log files that are processed in parallel by the number.

number of log files chunk side 201 or more and 1000 or less 1 MB 101 or more and 200 or less 5 MB 51 or more and 100 or less 10 MB 1 or more and 50 or less 20 MB

Table 1 shows exemplary chunk sizes that may be determined based on the number of log files when the maximum available memory size is 1 GB. Referring to Table 1, when the number of log files exceeds 1000, the number of log files that are simultaneously processed in parallel is set to 1000, and the chunk size is set to 1MB, so that 1MB chunks are read from 1000 files. It is possible to ensure that the sum of the memory sizes required for this operation does not exceed 1 GB. Referring to Table 1, if the number of log files is 201 or more and 1000 or less, the chunk size may be set to 1 MB, and if the number of log files is 101 or more and 200 or less, the chunk size may be set to 5 MB. Also, when the number of log files is 51 or more and 100 or less, the chunk size may be set to 10 MB, and when the number of log files is 1 or more and 50 or less, the chunk size may be set to 20 MB.

In other words, by determining the chunk size so as not to exceed the value obtained by dividing the maximum available memory size by the number of log files to be processed concurrently, the sum of the memory sizes used to read chunks from a plurality of log files determines the maximum available memory size. can be guaranteed not to exceed.

On the other hand, it was found as a result of the experiment that the overall processing time no longer decreased even if the chunk size increased by a certain size or more. 6 is a graph showing the results of examining the processing completion time (response time) while changing the chunk size. As shown in FIG. 6 , as the chunk size increases from 0 MB to 20 MB, the processing completion time decreases rapidly. This is because an excessively small chunk size causes excessively frequent file I/O, and the delay time due to the file I/O acts in a direction to increase the overall required time. On the other hand, if the chunk size exceeds 20 MB, it can be seen that the reduction in processing time is very small even if the chunk size is further increased. That is, according to the experimental results of FIG. 6 , it is preferable to increase the chunk size to about 20 MB. This indicates that, even if the number of log files is only one, it is preferable to set the chunk size to a size not exceeding 20 MB, rather than setting the maximum available memory size (eg, 1 GB) as the chunk size.

It will be described again with reference to FIG. 5 . In step S300, access log data is read in parallel from a plurality of access log files in chunks of the size determined in step S200, and in step S400, the access log data is stored through appropriate processing. stored in a structure. Steps S300 and S400 will be described in more detail with reference to FIGS. 7 to 9B .

FIG. 7 is a diagram for explaining in more detail some steps of the method of analyzing an access log described with reference to FIG. 5 .

Referring to FIG. 7 , first, data corresponding to a chunk size is read from the file in step S310 . Step S310 may be implemented using, for example, a FileReader object of JavaScript, but the present invention is not limited thereto.

In step S320, one line is acquired from the chunk data read in step S310. Step S320 may be performed, for example, by obtaining one line from an array in which chunk data is divided and stored in line units.

Subsequently, in step S400, one log line is processed and stored in a data structure. Step S400 will be described later in more detail.

In step S330, it is determined whether the last line of chunk data has been reached. That is, whether all lines included in the chunk data have been processed. If the last line is not reached, the process returns to step S320 to obtain the next log line from the chunk data, and repeats the process of processing and storing it in step S400. If it is determined in step S330 that the last line has been reached, the process proceeds to step S340.

In step S340, it is determined whether the last chunk of the log file has been reached. In other words, it is determined whether reading to the last part of the log file has been completed. If reading is not completed until the last part of the log file, the process returns to step S310 and new data corresponding to the chunk size is read from the file. Then, the process of reading the log from the newly read chunk data line by line (step S320), processing and storing (step S400) is repeated. If it is determined in step S330 that the last chunk has been reached, the analysis of the access log file is terminated.

8 to 9B are diagrams for explaining in more detail a process of processing and storing log lines in a data structure in step S400 of FIGS. 6 and 7 .

The pseudo code shown in FIG. 9A shows a method of reading each line from chunk data and storing it in a Map object for subsequent processing such as statistical analysis. Specifically, referring to FIG. 9A , from 'text' in which chunk data is recorded, each line is stored in an array 'lines' using a newline character '\r\n' as a delimiter. Each log line ('lines[j]') is stored in the Map object 'tpmMap' while traversing the array 'lines'.

However, when a Map object is used inside the code that processes the FileReader.onload event as in the pseudo code of FIG. 9a, the data read from a large number of analysis files disappears from the JavaScript memory space, but remains in the actual physical memory. A memory leak will occur. If the memory leak continues, the application program (such as a web browser) that executes the code is abnormally terminated, and the analysis of the log cannot be completed.

In order to solve the above problem, it is preferable to deep copy the data of the array 'lines' into a Map object in the code that processes the FileReader.onload event. 8 is a flowchart illustrating an exemplary process of deep copying data of an array 'lines' into a Map object, and FIG. 9B is a pseudocode thereof.

Referring to FIG. 8 , in step S410 , a first JavaScript object in which one line of the access log is stored is obtained. This corresponds to a part in the pseudo code of FIG. 9B that obtains each log line ('lines[j]') while traversing the array 'lines'.

In step S420, the first JavaScript object is converted into a JSON string. This corresponds to the part in which the json.stringify function is called for 'lines[j]' in the pseudo code of FIG. 9B.

In step S430, the JSON string is converted into a second JavaScript object. This corresponds to the part of calling the json.parse function on the result value of the json.stringify function in the pseudo code of FIG. 9B and assigning the result to the tpmMap.

Through the steps shown in Fig. 8, by converting the object in which the log data of one line is stored into a string and then converting the string back to a JavaScript object, inside the code that processes the FileReader.onload event, it is assigned to the Map object. The memory leak problem is solved.

In the above description with reference to FIGS. 8 to 9B, it is assumed that the present embodiment is implemented in a JavaScript language for convenience of description, but it should be noted that the present invention is not limited to such an embodiment.

The log analysis method according to an embodiment of the present invention, which has been described with reference to FIGS. 3 to 9B so far, does not need to transmit a large number of large-capacity log files generated by an analysis target computing device to a separate analysis server, It can be read and analyzed from a client device such as a local PC.

In addition, since the log analysis method according to an embodiment of the present invention can be implemented in a Java scripter language that can be executed in a web browser, it has excellent compatibility and does not require a cumbersome installation process.

Furthermore, the log analysis method according to an embodiment of the present invention allows a large number of log files to be read into memory in parallel and processed at the same time, and the most appropriate read unit (chunks) in view of the number of log files being processed at the same time. size) to minimize the overall processing time.

In addition, the log analysis method according to an embodiment of the present invention provides the above-described advantages, and at the same time solves the problem of memory leaks that occur frequently in the process of processing and storing large amounts of data in a web browser by using a deep copy method. .

So far, a method for measuring performance of a computing device and a log analysis method according to some embodiments of the present invention have been described with reference to FIGS. 1 to 9B . Hereinafter, an exemplary computing device 1500 capable of implementing methods according to some embodiments of the present invention will be described.

10 is a hardware configuration diagram illustrating an exemplary computing device 1500 that may implement some embodiments of the present invention.

10 , the computing device 1500 loads one or more processors 1510 , a bus 1550 , a communication interface 1570 , and a computer program 1591 executed by the processor 1510 . ) may include a memory 1530 and a storage 1590 for storing a computer program 1591 . However, only the components related to the embodiment of the present invention are illustrated in FIG. 10 . Accordingly, a person skilled in the art to which the present invention pertains can see that other general-purpose components other than the components shown in FIG. 10 may be further included.

The processor 1510 controls the overall operation of each component of the computing device 1500 . The processor 1510 includes a central processing unit (CPU), a micro processor unit (MPU), a micro controller unit (MCU), a graphic processing unit (GPU), or any type of processor well known in the art. can be In addition, the processor 1510 may perform an operation on at least one application or program for executing the method according to the embodiments of the present invention. The computing device 1500 may include one or more processors.

The memory 1530 stores various data, commands, and/or information. The memory 1530 may load one or more programs 1591 from the storage 1590 to execute a method according to embodiments of the present invention. The memory 1530 may be implemented as a volatile memory such as RAM, but the technical scope of the present invention is not limited thereto.

The bus 1550 provides communication functions between components of the computing device 1500 . The bus 1550 may be implemented as various types of buses, such as an address bus, a data bus, and a control bus.

The communication interface 1570 supports wired/wireless Internet communication of the computing device 1500 . Also, the communication interface 1570 may support various communication methods other than Internet communication. To this end, the communication interface 1570 may be configured to include a communication module well-known in the art.

According to some embodiments, the communication interface 1570 may be omitted.

The storage 1590 may non-temporarily store the one or more programs 1591 and various data.

The storage 1590 is a non-volatile memory such as a read only memory (ROM), an erasable programmable ROM (EPROM), an electrically erasable programmable ROM (EEPROM), a flash memory, a hard disk, a removable disk, or well in the art to which the present invention pertains. It may be configured to include any known computer-readable recording medium.

The computer program 1591 may include one or more instructions that, when loaded into the memory 1530 , cause the processor 1510 to perform methods/operations in accordance with various embodiments of the present invention. That is, the processor 1510 may perform the methods/operations according to various embodiments of the present disclosure by executing the one or more instructions.

In this case, the method according to some embodiments of the present invention may be implemented through the computing device 1500 .

So far, various embodiments of the present invention and effects according to the embodiments have been described with reference to FIGS. 1 to 10 . Effects according to the technical spirit of the present invention are not limited to the above-mentioned effects, and other effects not mentioned will be clearly understood by those skilled in the art from the following description.

The technical ideas of the present invention described with reference to FIGS. 1 to 10 may be implemented as computer-readable codes on a computer-readable medium. The computer-readable recording medium may be, for example, a removable recording medium (CD, DVD, Blu-ray disk, USB storage device, removable hard disk) or a fixed recording medium (ROM, RAM, computer-equipped hard disk). can The computer program recorded in the computer-readable recording medium may be transmitted to another computing device through a network such as the Internet and installed in the other computing device, thereby being used in the other computing device.

In the above, even if all the components constituting the embodiment of the present invention are described as being combined or operating in combination, the technical spirit of the present invention is not necessarily limited to this embodiment. That is, within the scope of the object of the present invention, all the components may operate by selectively combining one or more.

Although acts are shown in a specific order in the drawings, it should not be understood that the acts must be performed in the specific order or sequential order shown, or that all shown acts must be performed to obtain a desired result. In certain circumstances, multitasking and parallel processing may be advantageous. Moreover, the separation of the various components in the embodiments described above should not be construed as necessarily requiring such separation, and the described program components and systems may generally be integrated together into a single software product or packaged into multiple software products. It should be understood that there is

Although embodiments of the present invention have been described with reference to the accompanying drawings, those of ordinary skill in the art to which the present invention pertains can practice the present invention in other specific forms without changing the technical spirit or essential features. can understand that there is Therefore, it should be understood that the embodiments described above are illustrative in all respects and not restrictive. The protection scope of the present invention should be interpreted by the claims below, and all technical ideas within the equivalent range should be interpreted as being included in the scope of the technical ideas defined by the present invention.

Claims (13)

A method of analyzing a log by a computing device, comprising:
obtaining a plurality of log files;
determining a chunk size, which is a unit for reading data from each of the plurality of files;
reading the log from the plurality of files in the chunk unit, and reading at least some of the plurality of files in parallel; and
storing the log in a data structure
containing,
Log analysis method. According to claim 1,
The step of determining the chunk size includes:
determining the chunk size based on a maximum available memory size;
containing,
Log analysis method. 3. The method of claim 2,
The step of determining the chunk size includes:
determining the chunk size based on a value obtained by dividing the maximum available memory size by the number of the plurality of log files
containing,
Log analysis method. 4. The method of claim 3,
The chunk size is determined to be 20 MB or less,
Log analysis method. 5. The method of claim 4,
If the maximum available memory size is 1 GB,
When the number of log files is 1 or more and 50 or less, the chunk size is 20 MB,
When the number of log files is greater than or equal to 51 and less than or equal to 100, the chunk size is 10 MB,
When the number of log files is 101 or more and 200 or less, the chunk size is 5 MB,
When the number of the log files is 201 or more, the chunk size is 1 MB,
Log analysis method. According to claim 1,
Storing the log in a data structure comprises:
Deep copying each line of the log read in the chunk unit and storing it in the data structure,
Log analysis method. 7. The method of claim 6,
Deep copying each line and storing it in the data structure comprises:
obtaining a first JavaScript object in which one line of the log is stored;
converting the first JavaScript object into a JSON string; and
converting the JSON string into a second JavaScript object
containing,
Log analysis method. 8. The method of claim 7,
Converting the first JavaScript object to the JSON string comprises calling a JSON.stringify function,
Log analysis method. 8. The method of claim 7,
converting the JSON string into the second JavaScript object includes calling a JSON.parse function,
Log analysis method. According to claim 1,
Each step included in the method of analyzing the log is performed by a browser running on the computing device,
Log analysis method. According to claim 1,
Each step included in the method of analyzing the log is performed by the computing device without communication with an external device,
Log analysis method. A method of measuring the performance of a computing device, comprising:
analyzing the log of the target computing device;
automatically generating a test script based on the log analysis result;
testing the performance of the target computing device by executing the test script; and
displaying the test execution result
including,
The step of analyzing the log is,
acquiring a plurality of log files of the target computing device;
determining a chunk size, which is a unit for reading data from each of the plurality of files;
reading the log from the plurality of files in the chunk unit, and reading at least some of the plurality of files in parallel; and
storing the log in a data structure
containing,
A method of measuring the performance of a computing device. A computer program for causing a computer to perform the method of any one of claims 1 to 12 stored therein, a computer-readable non-transitory recording medium.

Images