Search

Logging is a common practice in software engineering. Prior research has investigated the characteristics of logging practices in system software (e.g., web servers or databases) as well as desktop applications. However, despite the popularity of mobile apps, little is known about their logging practices. In this paper, we sought to study logging practices in mobile apps. In particular, we conduct a case study on 1,444 open source Android apps in the F-Droid repository. Through a quantitative study, we find that although mobile app logging is less pervasive than server and desktop applications, logging is leveraged in almost all studied apps. However, we find that there exist considerable differences between the logging practices of mobile apps and the logging practices in server and desktop applications observed by prior studies. In order to further understand such differences, we conduct a firehouse email interview and a qualitative annotation on the rationale of using logs in mobile app development. By comparing the logging level of each logging statement with developers' rationale of using the logs, we find that all too often (35.4%), the chosen logging level and the rationale are inconsistent. Such inconsistency may prevent the useful runtime information to be recorded or may generate unnecessary logs that may cause performance overhead. Finally, to understand the magnitude of such performance overhead, we conduct a performance evaluation between generating all the logs and not generating any logs in eight mobile apps. In general, we observe a statistically significant performance overhead based on various performance metrics (response time, CPU and battery consumption). In addition, we find that if the performance overhead of logging is significantly observed in an app, disabling the unnecessary logs indeed provides a statistically significant performance improvement. Our results show the need for a systematic guidance and automated tool support to assist in mobile logging practices. [ABSTRACT FROM AUTHOR]

Logs are very important as they provide details of a systems past events as well as help in system monitoring, troubleshooting and forensics. In order to be useful the logging process must be done in a secure manner and logging files must be kept secure for an extended period of time as they may contain sensitive information. However, deploying a logging infrastructure is an expensive and time-consuming task. A natural solution to this problem these days is to use cloud storage for keeping logs, because of the benefits provided by cloud computing thus delegating the log management to a cloud service provider (CSP). This paper introduces secure log as a service using reversible watermarking (SecLaaS-RW) scheme. Reversible watermarking is a type of fragile watermarking, which can be used for content authentication. The content in our case are outsourced logs, to which reversible watermarking is applied. Log records are collected using syslog, processed at the logging server and then transferred to an outsource cloud storage, where all records are saved for extended period of time. We have made comparison with a recently proposed scheme. Our experimental results suggest that with a very limited and manageable overhead per log entry, modifications in the outsourced logs can be detected. [ABSTRACT FROM AUTHOR]

MultiLog is a logging tool that controls, gathers, and combines the output, on-the-fly, from existing research and commercial logging applications or 'loggers.' Loggers record a specific set of user actions on a computing device, helping researchers to better understand environments or interactions, guiding the design of new or improved interfaces and applications. MultiLog reduces researchers' required implementation effort by simplifying the set-up of multiple loggers and seamlessly combining their output. This in turn increases the availability of logging systems to non-technical experimenters for both short-term and longitudinal observation studies. MultiLog supports two operating modes: 'researcher mode' where experimenters configure multiple logging systems, and 'deployment mode' where the system is deployed to user-study participants' systems. Researcher mode allows researchers to install, configure log filtering and obfuscation, observe near real-time event streams, and save configuration files ready for deployment. Deployment mode simplifies data collection from multiple loggers by running in the system tray at user log-in, starting loggers, combining their output, and securely uploading the data to a web-server. It also supports real-time browsing of log data, pausing of logging, and removal of log lines. Performance evaluations show that MultiLog does not adversely affect system performance, even when simultaneously running several logging systems. Initial studies show the system runs reliably over a period of 10 weeks. [ABSTRACT FROM AUTHOR]

With the ever-increasing complexity of digital designs, debugging and evaluation face likewise increasing challenges. While recent advances in hardware/software co-simulation have been made, solutions for corresponding debugging and evaluation did not mature and improve in a similar fashion. In this article, we present a dedicated solution to ease the debugging and evaluation efforts, particularly focusing on full-system simulation. Improving significantly over existing solutions, the presented approach features a standardscompliant powerful and flexible method of deriving, logging, and filtering detailed status information from SystemC-based models. At the core of this approach are flexible scripting capabilities that may change all logging parameters during runtime, thus not requiring re-compiling the to-be-simulated model, as in many competing solutions. The approach is tested and benchmarked with a real-world full-system example, demonstrating the overall benefits. The presented solution is published as open source via github (see text) and, by strictly adhering to existing standards, is generally compatible with existing SystemC simulation environments. [ABSTRACT FROM AUTHOR]

This paper conducts an examination of log files originating from High Performance Computing (HPC) applications with known reliability problems. The results of this study further the maturation and adoption of meaningful metrics representing HPC system and application failure characteristics. Quantifiable metrics representing the reliability of HPC applications are foundational for building an application resilience methodology critical in the realization of exascale supercomputing. In this examination, statistical inequality methods originating from the study of economics are applied to health and status information contained in HPC application log files. The main result is the derivation of a new failure index metric for HPC—a normalized representation of parallel application volatility and/or resiliency to complement existing reliability metrics such as mean time between failure (MTBF), which aims for a better presentation of HPC application resilience. This paper provides an introduction to a Failure Index (FI) for HPC reliability and takes the reader through a use-case wherein the FI is used to expose various run-time fluctuations in the failure rate of applications running on a collection of HPC platforms. [ABSTRACT FROM AUTHOR]

Event logging is an important technique for networked embedded systems like wireless sensor networks. It can greatly help developers to understand complex system behaviors and diagnose program bugs. Existing logging facilities do not well satisfy three practical requirements: flexibility, efficiency, and high synchronization accuracy. To simultaneously satisfy these requirements, we present Dylog, a dynamic logging facility for networked embedded systems. Dylog employs several techniques. First, Dylog uses binary instrumentation for dynamically inserting or removing logging statements, enabling flexible and interactive debugging at runtime. Second, Dylog incorporates an efficient storage system and log collection protocol for recording and transferring the logging messages. Third, Dylog employs a lightweight data-driven approach for reconstructing the synchronized time of the logging messages. Dylog uses MAC-layer timestamping and drift compensation to achieve high synchronization accuracy. We implement Dylog on the TinyOS 2.1.1/TelosB platform. Results show the following: (1) Dylog incurs a small overhead. Indirections in Dylog incur an additional execution overhead of less than 1%. Dylog reduces the logging storage size by approximately 50% compared with the standard TinyOS radio printf library. Dylog reduces the patch size by more than 90%, compared with incremental reprogramming. (2) Dylog reduces the synchronization overhead by 78% in terms of transmission cost, compared with a traditional time synchronization protocol, FTSP, and it can achieve a high time synchronization accuracy of 5.4µs. (3) Dylog can help diagnose system problems effectively at the source-code level for three real-world scenarios. [ABSTRACT FROM AUTHOR]

Mobile nodes (MNs) have multiple interfaces for accessing heterogeneous networks. The multiple interfaces enable the MNs to access diverse networks simultaneously, and allocate or redirect data flows dynamically across the networks. In this paper, we introduce scalable network-based mobility management architecture and propose flow mobility management scheme for the multi-connectivity management in the multi-access and multi-homing context. They are simulated using NS-3 simulator. The proposed flow mobility management scheme is verified by a complicate scenario, which includes as many cases of flow handover as possible. [ABSTRACT FROM AUTHOR]

Programming development tools are a vital component for understanding the behavior of parallel applications. Event tracing is a principal ingredient to these tools, but new and serious challenges place event tracing at risk on extreme-scale machines. As the quantity of captured events increases with concurrency, the additional data can overload the parallel file system and perturb the application being observed. In this work we present a solution for event tracing on extreme-scale machines. We enhance an I/O forwarding software layer to aggregate and reorganize log data prior to writing to the storage system, significantly reducing the burden on the underlying file system. Furthermore, we introduce a sophisticated write buffering capability to limit the impact. To validate the approach, we employ the Vampir tracing toolset using these new capabilities. Our results demonstrate that the approach increases the maximum traced application size by a factor of 5× to more than 200,000 processes. [ABSTRACT FROM AUTHOR]

SUMMARY Logging and replay provide numerous benefits for debugging today's increasingly distributed and parallel applications, as well as for debugging within cloud computing environments. Tracking down faults, particularly in applications that involve non-deterministic executions, becomes much easier if such a technique is used. This article presents a system that leverages the functionality of modern x86 hardware extensions present in Intel and AMD processors to implement logging and replay of the Kernel-based Virtual Machine (KVM). With our KVM-based logging and replay system, virtual machines can be logged at will. The system can record the behavior of the operating system, the applications, the network traffic, and the user input. At a later time, and even on another machine, the problematic execution can be replayed and analyzed. The implementation incurs a minimal amount of processing and memory overhead, and thus, its effects are largely imperceptible to users of the system. Copyright © 2011 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Keystroke logging has become instrumental in identifying writing strategies and understanding cognitive processes. Recent technological advances have refined logging efficiency and analytical outputs. While keystroke logging allows for ecological data collection, it is often difficult to connect the fine grain of logging data to the underlying cognitive processes. Multiple methodologies are useful to offset these difficulties. In this article we explore the complementarity of the keystroke logging program Inputlog with other observational techniques: thinking aloud protocols and eyetracking data. In addition, we illustrate new graphic and statistical data analysis techniques, mainly adapted from network analysis and data mining. Data extracts are drawn from a study of writing from multiple sources. In conclusion, we consider future developments for keystroke logging, in particular letter- to word-level aggregation and logging standardization. [ABSTRACT FROM PUBLISHER]

We start by reviewing several logging tools. We then report improvements to a keystroke logger we have developed for the Mac and PC, Recording User Input (RUI). These improvements include changes to its interface, increased accuracy and extensions to its logging ability. RUI runs in the background recording user behavior with timestamps and mouse location data across all applications—thus avoiding problems associated with video logs and instrumenting individual applications. We provide a summary and comparison of tests for loggers and present procedures for validating logger timing that quantifies timing accuracy using an external clock. We demonstrate these tests on RUI and three other applications (Morae, Camtasia and AppMonitor). We conclude by providing some general specifications and considerations for creating, testing, evaluating and using keystroke and mouse loggers with respect to different experimental questions and tasks. [ABSTRACT FROM AUTHOR]

With our current expectation for the exascale systems, composed of hundred of thousands of many-core nodes, the mean time between failures will become small, even under the most optimistic assumptions. One of the most scalable checkpoint restart techniques, the message logging approach, is the most challenged when the number of cores per node increases because of the high overhead of saving the message payload. Fortunately, for two processes on the same node, the failure probability is correlated, meaning that coordinated recovery is free. In this paper, we propose an intermediate approach that uses coordination between correlated processes but retains the scalability advantage of message logging between independent ones. The algorithm still belongs to the family of event logging protocols but eliminates the need for costly payload logging between coordinated processes. [ABSTRACT FROM AUTHOR]

The paper deals with the problem of creating a knowledge database on system dependability and resilience, created on the basis of available system and application logs. Special tools to collect and analyse these data from many systems have been de-veloped. Taking into account a wide spectrum of various logs we explore them locally and globally. This allowed for identification of characteristics of normal operation and anomalous behaviour. A lot of attention is paid to the problem of selecting measures to identify symptoms characterising system operation and their usefulness in dependability and resilience evaluation or prediction. The concepts presented are illustrated with experience gained during monitoring of real systems. [ABSTRACT FROM AUTHOR]

Enterprise systems produce a vast amount of logging data. This critical and valuable information must be processed automatically for timely system analysis and recovery. As a result of industry demands, a standard database containing known issues has been introduced - a symptom database. Each symptom consists of a rule pattern and corresponding solutions. Patterns used for symptom identification are encoded as a XPath expression and matched against a stream of events in a standardised WSGI format common base event. The ability of an efficient matching for symptom patterns has been raised as an important requirement by industries. The authors present a real-time symptom identification in a stream of events. The implementation will allow multiple autonomic computing components such as self-monitoring sensors to effectively match known patterns in large datasets in run time. Unlike current state of the art approaches, the proposed solution allows users to define patterns using all the complex XPath functions in addition to standard numeric and Boolean operators. In particular, it was aimed at efficient simultaneous matching of a large set of XPath-based symptom patterns against a high-volume event stream, which is crucial for symptom identification but was not addressed efficiently by currently available XPath-matching engines. [ABSTRACT FROM AUTHOR]

The article offers information on cloud computing which has applications that can be accessed upon user log-on. It notes that enhanced accessibility to cloud solutions are provided by service integrators which procure and install applications. It mentions that the hassle of hardware and software maintenance is removed by cloud computing.

Abstract: There has been a surge of interest for multimedia applications over wireless networks in recent years. A colossal number of ways have been proposed to decrease delay, delay jitter and loss in wireless networks and good user-perceived quality in video over internet. This paper studies the multimedia over heterogeneous wireless networks, requirements and problems, and proposes a new scheme to overcome the obstacles. The proposed scheme, takes into account the effects of Application-Level Wireless Multilevel ECN marking (AWMECN), thus helps us overcome the congestion/loss mistake problems. For handoff, handover and lossy link problems, it is considered that a freezing mechanism is in use in application layer and assumed that the upper layers can be aware of disconnection periods to make the rate adaptation decisions. Also a new scheme has been added to receiver to gracefully degrade the quality when no other action is available to combat the long delays without data which is caused by handoffs and wireless temporary disconnections. The transport layer mechanism is chosen to be UDP for avoiding TCP regarding problems. We believe that obtaining a good quality of video depends on good performance of all layers and tried to use the best mechanism in each layer. [Copyright &y& Elsevier]

Abstract: In a distributed computing system, message logging is widely used for providing nodes with recoverability. To reduce the piggyback overhead of traditional causal message logging, we present a zoning causal message logging approach in this paper. The crux of the approach is to control the propagation of dependency information: the nodes in the system are divided into zones, and by a message fragment mechanism, the dependency information of a node is only visible in the zone scope. Simulation results show that the piggyback overhead of the proposed approach is lower than that of traditional causal message logging. [Copyright &y& Elsevier]

In the rollback recovery of large-scale long-running applications in a distributed environment, pessimistic message logging protocols enable failed processes to recover independently, though at the expense of logging every message synchronously during fault-free execution. In contrast, coordinated checkpointing protocols avoid message logging, but they are poor in scalability with a sharply increased coordinating overhead as the system grows. With the aim of achieving efficient rollback recovery by trading off logging overhead and coordinating overhead, this paper suggests a partitioning of the system into clusters, and then presents a scheme to implement the conversion between these overheads. Using the proposed conversion, coordination can be introduced to reduce the unbearable logging overhead found in some systems, whereas proper logging can be employed to alleviate the unacceptable coordinating overhead in others. Furthermore, heuristics are introduced to address the issue of how to partition the system into clusters in order to speed up the recovery process and to improve recovery efficiency. Performance evaluation results indicate that our scheme can lower the overall system overhead effectively. Copyright © 2008 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Tracing IP packets back to their origins is an important step in defending the Internet against denial-of-service (DOS) attacks. Two kinds of P traceback techniques have been proposed as packet marking and packet logging approaches. In packet marking, routers probabilistically write their identification information into the forwarded packets. This approach incurs little overhead but requires a large flow of packets to collect the complete path information. In packet logging, routers record the digests of the forwarded packets. This approach makes it possible to trace even a single packet and hence is considered more powerful. At routers forwarding a large volume of traffic, however, the high storage overhead and access time requirement for recording packet digests introduce practicality problems. In this paper, we present a novel scheme to improve the practicality of log-based IP traceback by reducing its overhead on routers. Our approach makes an intelligent use of packet marking to help improve the scalability of log-based IP traceback. We use mathematical analysis and simulations to evaluate our approach. Our evaluation results show that compared to the state-of-the-art log-based approach called Source Path Isolation Engine (SPIE), our approach maintains the ability to trace a single IP packet while reducing the storage overhead by half and the access time overhead by a factor of the number of neighboring routers. [ABSTRACT FROM AUTHOR]

Execution logs are generated by output statements that developers insert into the source code. Execution logs are widely available and are helpful in monitoring, remote issue resolution, and system understanding of complex enterprise applications. There are many proposals for standardized log formats such as the W3C and SNMP formats. However, most applications use ad hoc non-standardized logging formats. Automated analysis of such logs is complex due to the loosely defined structure and a large non-fixed vocabulary of words. The large volume of logs, produced by enterprise applications, limits the usefulness of manual analysis techniques. Automated techniques are needed to uncover the structure of execution logs. Using the uncovered structure, sophisticated analysis of logs can be performed. In this paper, we propose a log abstraction technique that recognizes the internal structure of each log line. Using the recovered structure, log lines can be easily summarized and categorized to help comprehend and investigate the complex behavior of large software applications. Our proposed approach handles free-form log lines with minimal requirements on the format of a log line. Through a case study using log files from four enterprise applications, we demonstrate that our approach abstracts log files of different complexities with high precision and recall. Copyright © 2008 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Finding yourself in a situation with a working and a buggy system is quite common. Differential debugging methodically can help by comparing a known good system with a buggy one, working toward the problem source. Some simple steps include applying differential debugging by looking at log files and increasing a system's log verbosity when needed. If the system doesn't offer a sufficiently detailed logging mechanism, you can tease out its runtime behavior with tools that trace calls to the operating system or that trace network packets. You can also compare carefully the two environments where the systems operate. The Web extra at http://youtu.be/qnXS6b4hakg is an audio podcast of author Diomidis Spinellis reading his Tools of the Trade column, in which he discusses how comparing a good system with a buggy one can help locate the source of the problem. [ABSTRACT FROM PUBLISHER]