Search 250 million research papers

Read the abstract, see who wrote it and who cites it, and get the citation in APA, MLA, Chicago or Harvard.

About 1,130 papers for “stack traces”

stack traces Infologic

Infologic R D · Zenodo (CERN European Organization for Nuclear Research) · 2023

Cited by 0Open access

Approximating Attack Surfaces with Stack Traces

Christopher Theisen, Kim Herzig, Patrick Morrison et al. · 2015 IEEE/ACM 37th IEEE International Conference on Software Engineering · 2015

Security testing and reviewing efforts are a necessity for software projects, but are time-consuming and expensive to apply. Identifying vulnerable code supports decision-making during all phases of software development. An approach for identifying vulnerable code is to identify its attack surface, the sum of all paths for untrusted data into and out of a system. Identifying the code that lies on the attack surface requires expertise and significant manual effort. This paper proposes an automated technique to empirically approximate attack surfaces through the analysis of stack traces. We hypothesize that stack traces from user-initiated crashes have several desirable attributes for measuring attack surfaces. The goal of this research is to aid software engineers in prioritizing security efforts by approximating the attack surface of a system via stack trace analysis. In a trial on Windows 8, the attack surface approximation selected 48.4% of the binaries and contained 94.6% of known vulnerabilities. Compared with vulnerability prediction models (VPMs) run on the entire codebase, VPMs run on the attack surface approximation improved recall from .07 to .1 for binaries and from .02 to .05 for source files. Precision remained at .5 for binaries, while improving from .5 to .69 for source files.

Cited by 30

winch: Portable Native and Joint Stack Traces

Kirill Müller, Ian Lance Taylor · 2020

Cited by 0Open access

Finding the needle: stack traces for GHC

Tristan Allwood, Simon Peyton Jones, Susan Eisenbach · 2009

Even Haskell programs can occasionally go wrong. Programs call-ing head on an empty list, and incomplete patterns in function def-initions can cause program crashes, reporting little more than the precise location where error was ultimately called. Being told that one application of the head function in your program went wrong, without knowing which use of head went wrong can be infuriating. We present our work on adding the ability to get stack traces out of GHC, for example that our crashing head was used during the evaluation of foo, which was called during the evaluation of bar, during the evaluation of main. We provide a transformation that converts GHC Core programs into ones that pass a stack around, and a stack library that ensures bounded heap usage despite the highly recursive nature of Haskell. We call our extension to GHC

Cited by 0

SlowOps: An Industrial Dataset of Stack Traces

Shibaev, Egor, Sushentsev, Denis, Golubev, Yaroslav et al. · Zenodo (CERN European Organization for Nuclear Research) · 2024

This package contains SlowOps, and industrial dataset of stack traces introduced in our paper "Stack Trace Deduplication: Faster, More Accurately, and in More Realistic Scenarios". SlowOps is an dataset of stack traces (reports) and their categories (issues), aimed at evaluating different models for stack trace deduplication. The dataset includes reports related to Slow Operation Assertion, collected at JetBrains from IntelliJ-based products in the time from 26.01.2021 to 29.02.2024. It contains 886,730 reports in 1,361 categories. For more information about the dataset, please refer to the README.

Cited by 0Open access

SlowOps: An Industrial Dataset of Stack Traces

Shibaev, Egor, Sushentsev, Denis, Golubev, Yaroslav et al. · Zenodo (CERN European Organization for Nuclear Research) · 2024

Cited by 0Open access

Do stack traces help developers fix bugs

Nicolas Bettenburg, Rahul Premraj · 2010

Abstract—A widely shared belief in the software engineering community is that stack traces are much sought after by developers to support them in debugging. But limited empirical evidence is available to confirm the value of stack traces to developers. In this paper, we seek to provide such evidence by conducting an empirical study on the usage of stack traces by developers from the ECLIPSE project. Our results provide strong evidence to this effect and also throws light on some of the patterns in bug fixing using stack traces. We expect the findings of our study to further emphasize the importance of adding stack traces to bug reports and that in the future, software vendors will provide more support in their products to help general users make such information available when filing bug reports. Keywords-debugging, stack traces, empirical study, bug tracking, collaboration I.

Cited by 0

Cross Platform Bug Correlation Using Stack Traces

Maryam Abdul Ghafoor, Junaid Haroon Siddiqui · 2016

Crashing of program is an annoying experience for users. Whenever a program crashes, an event log is generated. Sometimes built in crash reporting programs send crash reports automatically to developing site whereas sometimes, user is presented with an option to report the crash himself. This reporting is often useful for the development team to diagnose and fix the problem. It happens quite often that code that crashes a program is not the reason for the crash itself but crash is due to the use of some faulty function or library of some other program. We propose a method to identify cross platform bug correlation to detect faulty functions, using function call stack information given in bug reports. We collect and process bug reports from multiple platforms to compute similarity based on our similarity metric between occurrence sequences of the function calls within different bug reports. For the solved bug we extract information about faulty function by analyzing its bug report to propose fix of the similar bug with same function within correlated bug report. If there exists fix of one bug in one application, it can be used to resolve similar bug in some other application. Using our technique we found similar bug reports. We were able to find cases for similar bug reports that have same reason for the cause of bug and were using same fix.

Cited by 3

Predictive Deconvolution On Seismic Traces: How Does Decon Before Stack Affect Decon After Stack?

J. Fatti, Bertram Müller · 1993

When predictive deconvolution is applied to seismic traces usïng prediction distance longer than one sample interval, the output seismic wavelet is a truncated version of the input wavelet, and is not minimum phase. Therefore when predictive deconvolution before stack is followed by predictive deconvolution after stack, the decon after stack sometimes produces a serious distortion of the wavelet. This happens when the after-stack prediction distance is shorter than the before-stack prediction distance.

Cited by 0

Ground stack tree rewriting and traces of counter systems

Vincent Penelle · theses.fr (ABES) · 2015

Dans cette thèse, nous nous attachons à étudier des classes de graphes infinis et leurs propriétés, Notamment celles de vérification de modèles, d'accessibilité et de langages reconnus.Nous définissons une notion d'arbres de piles ainsi qu'une notion liée de réécriture suffixe, permettant d'étendre à la fois les automates à piles d'ordre supérieur et la réécriture suffixe d'arbres de manière minimale. Nous définissons également une notion de reconnaissabilité sur les ensembles d'opérations à l'aide d'automates qui induit une notion de reconnaissabilité sur les ensembles d'arbres de piles et une notion de normalisation des ensembles reconnaissables d'opérations analogues à celles existant sur les automates à pile d'ordre supérieur. Nous montrons que les graphes définis par ces systèmes de réécriture suffixe d'arbres de piles possèdent une FO-théorie décidable, en montrant que ces graphes peuvent être obtenu par une interprétation à ensembles finis depuis un graphe de la hiérarchie à piles.Nous nous intéressons également au problème d'algébricité des langages de traces des systèmes à compteurs et au problème lié de la stratifiabilité d'un ensemble semi-linéaire. Nous montrons que dans le cas des polyèdres d'entiers, le problème de stratifiabilité est décidable et possède une complexité coNP-complète. Ce résultat nous permet ensuite de montrer que le problème d'algébricité des traces de systèmes à compteurs plats est décidable et coNP-complet. Nous donnons également une nouvelle preuve de la décidabilité des langages de traces des systèmes d'addition de vecteurs, préalablement étudié par Schwer

Cited by 0Open access

Investigating the usefulness of stack traces in bug triaging

M.M. Krikke · Research Repository (Delft University of Technology) · 2012

In software engineering, resources such as time, money and developers, are limited. Often when bugs are found in the software developed, bug triaging is used to prioritise bug reports and allocate resources to it. When the number of bugs is considerable, this will require a vast amount of time and effort. The goal of this research is to investigate the usefulness of stack traces in bug reports for the assessment of bug report properties, using existing metrics of bug reports and files, being severity, priority and time-to-fix. In order to investigate the usefulness of stack traces, a research framework and methodology are developed. Overall, we can conclude that stack traces can be used to link software artifacts. Also, stack traces can be a valuable input for prediction models, for example using metrics of related bugs and source files.

Cited by 1Open access

Identifying and Detecting Inaccurate Stack Traces in Bug Reports

Meher Kiran Bheree, John Anvik · 2024

Bug reports contain a combination of structured and unstructured information, with the stack trace being one of the most important structured pieces of information. However, stack traces that do not contain accurate fault location information can lead to significant delays in software maintenance. This work examines eight projects from two open-source software communities to understand how to identify and detect inaccurate stack traces in bug reports. Using our approach to detecting inaccurate stack traces, we found that accurate fault location information is found roughly $33 \%$ of the time in the top frame, ${5 0 \%}$ in the Top-3 frames, ${7 5 \%}$ in the Top-5 frames and that the information accuracy does not significantly improve beyond this point. Next, we found that roughly $33 \%$ of stack traces can be considered inaccurate using the Top-5 stack trace frames. Third, NPEs commonly occur in inaccurate stack traces, and project-specific exceptions occur too infrequently to likely be useful in identifying inaccurate stack traces. Finally, the best machine learning classifier to identify inaccurate stack traces in a project’s bug reports uses a linear regression algorithm trained using the filename, method name and exception name from the top frame of a stack trace. Depending on the project, this classifier has a ${7 8 - 9 8 \%}$ accuracy, ${6 0 - 9 4 \%}$ precision, and $16-97 \%$ recall.

Cited by 2

Correlating Logs, Metrics, and Traces for Full-Stack Observability

Lakshmi Narasimha Rohith Samudrala · International Journal of Multidisciplinary Research and Growth Evaluation · 2021

Logs, Metrics, and Traces serve as three pillars of observability. Each providing unique and valuable information, but the true power of these pillars can only be realized when correlating them. When correlated the three pillars provide a unified, contextualized view of system behavior, essential for detecting performance bottlenecks, debugging failures, and optimizing service reliability. This paper talks about the importance of full-stack observability and explores how logs, metrics, and traces can be correlated with examples. The paper further examines the challenges organizations face, such as data fragmentation, context propagation issues, high storage costs, excessive alert noise, and presents best practices for seamless integration. Strategies such as usage of common identifier (trace ID), leveraging AI for automated correlation, implementing intelligent alerting, and optimizing data retention help teams build a scalable and efficient observability framework. The paper further explores the future trends in the field of full-stack observability such as AI-powered anomaly detection and unified OpenTelemetry adoption which will streamline observability workflows and enable predictive analytics.

Cited by 0Open access

Automatic bug triaging techniques using machine learning and stack traces

Koochekian Sabor, Korosh · Spectrum Research Repository (Concordia University) · 2019

When a software system crashes, users have the option to report the crash using automated bug tracking systems. These tools capture software crash and failure data (e.g., stack traces, memory dumps, etc.) from end-users. These data are sent in the form of bug (crash) reports to the software development teams to uncover the causes of the crash and provide adequate fixes. The reports are first assessed (usually in a semi-automatic way) by a group of software analysts, known as triagers. Triagers assign priority to the bugs and redirect them to the software development teams in order to provide fixes. \nThe triaging process, however, is usually very challenging. The problem is that many of these reports are caused by similar faults. Studies have shown that one way to improve the bug triaging process is to detect automatically duplicate (or similar) reports. This way, triagers would not need to spend time on reports caused by faults that have already been handled. Another issue is related to the prioritization of bug reports. Triagers often rely on the information provided by the customers (the report submitters) to prioritize bug reports. However, this task can be quite tedious and requires tool support. Next, triagers route the bug report to the responsible development team based on the subsystem, which caused the crash. Since having knowledge of all the subsystems of an ever-evolving industrial system is impractical, having a tool to automatically identify defective subsystems can significantly reduce the manual bug triaging effort.\nThe main goal of this research is to investigate techniques and tools to help triagers process bug reports. We start by studying the effect of the presence of stack traces in analyzing bug reports. Next, we present a framework to help triagers in each step of the bug triaging process. We propose a new and scalable method to automatically detect duplicate bug reports using stack traces and bug report categorical features. We then propose a novel approach for predicting bug severity using stack traces and categorical features, and finally, we discuss a new method for predicting faulty product and component fields of bug reports.\nWe evaluate the effectiveness of our techniques using bug reports from two large open-source systems. Our results show that stack traces and machine learning methods can be used to automate the bug triaging process, and hence increase the productivity of bug triagers, while reducing costs and efforts associated with manual triaging of bug reports.

Cited by 0Open access

What causes exceptions in machine learning applications? Mining machine learning-related stack traces on Stack Overflow

Amin Ghadesi, Maxime Lamothe, Heng Li · Empirical Software Engineering · 2024

Cited by 0

Performance debugging in the large via mining millions of stack traces

Shi Han, Yingnong Dang, Ge Song et al. · 2012

Given limited resource and time before software release, development-site testing and debugging become more and more insufficient to ensure satisfactory software performance. As a counterpart for debugging in the large pioneered by the Microsoft Windows Error Reporting (WER) system focusing on crashing/hanging bugs, performance debugging in the large has emerged thanks to available infrastructure support to collect execution traces with performance issues from a huge number of users at the deployment sites. However, performance debugging against these numerous and complex traces remains a significant challenge for performance analysts. In this paper, to enable performance debugging in the large in practice, we propose a novel approach, called StackMine, that mines callstack traces to help performance analysts effectively discover highly impactful performance bugs (e.g., bugs impacting many users with long response delay). As a successful technology-transfer effort, since December 2010, StackMine has been applied in performance-debugging activities at a Microsoft team for performance analysis, especially for a large number of execution traces. Based on real-adoption experiences of StackMine in practice, we conducted an evaluation of StackMine on performance debugging in the large for Microsoft Windows 7. We also conducted another evaluation on a third-party application. The results highlight substantial benefits offered by StackMine in performance debugging in the large for large-scale software systems.

Cited by 167

Introperf: Transparent context-sensitive multilayer performance inference using system stack traces

Chung Hwan Kim · 2014

Performance bugs are frequently observed in commodity soft-ware. While profilers or source code-based tools can be used at development stage where a program is diagnosed in a well-defined environment, many performance bugs survive such a stage and affect production runs. OS kernel-level tracers are commonly used in post-development diagnosis due to their independence from programs and libraries; however, they lack detailed program-specific metrics to reason about performance problems such as function latencies and pro-gram contexts. In this paper, we propose a novel perfor-mance inference system, called IntroPerf, that generates fine-grained performance information – like that from ap-plication profiling tools – transparently by leveraging OS tracers that are widely available in most commodity operat-ing systems. With system stack traces as input, IntroPerf enables transparent context-sensitive performance inference, and diagnoses application performance in a multi-layered scope ranging from user functions to the kernel. Evalu-ated with various performance bugs in multiple open source software projects, IntroPerf automatically ranks poten-tial internal and external root causes of performance bugs with high accuracy without any prior knowledge about or instrumentation on the subject software. Our results show IntroPerf’s effectiveness as a lightweight performance in-trospection tool for post-development diagnosis.

Cited by 0

Deobfuscate Non-Returning Calls and Call-Stack Tampering in Instruction Traces

Jing Qiu, Xiao Hong Su, Jun Pei · Advanced materials research · 2014

Instruction traces are essential for dynamic analysis in reverse engineering. Code in instruction traces is often obfuscated to hinder analysts from understanding and analyzing in malware and binaries that protected by packers. Non-returning calls and call-stack tampering are two typical kinds of such obfuscation. We propose a deobfuscation approach to fight against these two kinds of obfuscated code. We first apply static analysis on instruction traces to identify obfuscated code. Then we transform obfuscated code into semantically equivalent instructions to make the code be easy to understand. Evaluations results on some packed binaries indicate that our approach works well in deobfuscate instruction traces with non-returning calls and call-stack tampering in high precision.

Cited by 0

Lancaster University From stack traces to call-trees: outline of a proof

2009

This report outlines a proof of the theorem described in COSMOPEN: Dynamic reverse engineering on a budget, How cheap observation techniques can be used to reconstruct complex multi-level behaviour [1] on the construction of a minimal call-trees from stack traces. Please refer to original publication for details regarding the context of the work, the notation used, and definitions. We repeat below the pseudo-code of the call-tree construction algorithm, and present some key definitions in more detail. We then outline a proof of the characterisation of the call-tree constructed by the algorithm.

Cited by 0

Predicting Crash Causes from Stack Traces: Can We Identify Key Android Settings? (Artifact)

Anonymous, Anonymous · Zenodo (CERN European Organization for Nuclear Research) · 2025

These files are the artifact for the manuscript entitled `Predicting Crash Causes from Stack Traces: Can We IdentifyKey Android Settings?`. For more information, please read the README.md which explains the whole project located in Shark.zip.

Cited by 0Open access