#12096: Attach stacktrace information to SomeException -------------------------------------+------------------------------------- Reporter: ndtimofeev | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: Core Libraries | Version: 8.0.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Changes (by thomie): * cc: gridaphobe, ekmett (added) * component: libraries/base => Core Libraries -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/12096#comment:1 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#12096: Attach stacktrace information to SomeException -------------------------------------+------------------------------------- Reporter: ndtimofeev | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: Core Libraries | Version: 8.0.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by ndtimofeev): 1. I just copy `ErrorCall` API and implementation. Also I would like to see both stacktrace (`CallStack` and `CostCentreStack`, not only `CallStack`). 2. Yep, stacktrace information is lost when we catch unwraped exception. It looks like a problem. First: {{{#!hs f = throw (CustomException False) g = f `catch` \err@(CustomException fixable) -> if fixable then makeGood else throw err }}} We only rethrow exception and… change it stacktrace. Now it start from `throw` in `g`, not in `f`. Second: {{{#!hs onException eval handler = eval `catch` (\e@(SomeException _) -> handler

...

throw e)

f = throw (CustomException False) g = f `onException` makeGood }}} Now exception has to stacktrace. Third: {{{#!hs loop = forever $ threadDelay maxBound main = do tid <- forkIO $ loop `onException` putStrLn "Bang!" threadDelay 1000000 throwTo tid UserException }}} Now `UserException` has absolutely irrelevant stacktrace. I don't know how fix first problem. The second can be fixed something like that: {{{#!hs throw :: (HasCallStack, Exception e) => e -> a throw e | Just (SomeException _) <- cast e = raise# e | otherwise = unsafeDupablePerformIO $ do stack <- currentCallStack raise# (CallStackException e $ if stack /= [] then prettyCallStack ?callStack ++ "\n" ++ renderStack stack else prettyCallStack ?callStack) }}} The third is more complicated. For example we can skip stacktrace information for asynchronous exceptions. But in general, we can't determine this exception synchronous or asynchronous. Perhaps `throwTo` can add to exception extra information. But I do not understand how. {{{#!hs throwTo' :: Exception e => ThreadId -> e -> IO a throwTo' tid = throwTo tid . SomeAsyncException catch' :: Exception e => IO a -> (e -> IO a) -> IO a catch' eval handler = eval `catch` \err@(SomeException _) -> go err handler err where go :: (Exception e, Exception a) => e -> (a -> IO b) -> SomeException -> IO b go ex f origErr | Just v <- cast ex = f v | Just (SomeException inner) <- cast ex = go inner f origErr | Just (SomeAsyncException inner) <- cast ex = go inner f origErr | otherwise = throw origErr }}} Also it will be useful in situation like that: {{{#!hs processCmd = timeout 20000 . postDataAndWaitResponce main = do tasks <- newChan :: IO (Chan (String, MVar (Either SomeEception (Maybe String)))) tid <- forkIO $ forever $ do (cmd, ret) <- readChan tasks try (processCmd cmd) >>= putMVar ret threadDelay 1000000 throwTo tid UserException }}} `UserException` can't kill forked thread because it try catch all (synchronous) exception. If `try (processCmd cmd) >>= putMVar ret` will be masked `timeout` will be broken. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/12096#comment:3 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#12096: Attach stacktrace information to SomeException -------------------------------------+------------------------------------- Reporter: ndtimofeev | Owner: Type: feature request | Status: new Priority: normal | Milestone: Component: Core Libraries | Version: 8.0.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Changes (by mnislaih): * cc: mnislaih (added) -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/12096#comment:4 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#12096: Attach stacktrace information to SomeException -------------------------------------+------------------------------------- Reporter: ndtimofeev | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Core Libraries | Version: 8.0.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by ezyang): I don't think there is any way to attach a stack trace directly to the `SomeException` data type without breaking code that catches and rethrows exceptions of type `e` (with the constraint `Exception e`). So the not- very-nice conclusion is that we in fact *have* to embed the call stack in every exception type. This doesn't mean that `throw` can't also know how to attach call stacks: for example, the `Exception` type class could be extended with methods for getting and putting the call stack (and the exception instance can even make decisions like whether or not to keep all call stacks around, or just keep the first one, etc). -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/12096#comment:6 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#12096: Attach stacktrace information to SomeException -------------------------------------+------------------------------------- Reporter: ndtimofeev | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Core Libraries | Version: 8.0.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by ezyang): So, in my head, I want to minimize the amount of changes to code necessary to take advantage of call stacks. Adding CallStacks to each of the exception types individually means that you have to modify each exception type to contain a CallStack (so, linear in the number of exception types.) Creating a new `SomeExceptionWithCallStack` means that we have to modify all occurrences of catch-rethrow to preserve call stacks (so, linear in the number of catch-rethrows in code everywhere.) I admit that there is a tradeoff here, but the benefits of `SomeExceptionWithCallStack` don't make sense to me. I imagine there are a lot more catch-rethrows than there are exception types, and you will have to go through and fix each one of them. Admittedly, if you get a call stack that is missing info you need, it shouldn't be hard to track down (since the error will have the call stack of the bad rethrow attached :) Perhaps I am not seeing some other hidden costs? -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/12096#comment:8 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#12096: Attach stacktrace information to SomeException -------------------------------------+------------------------------------- Reporter: ndtimofeev | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Core Libraries | Version: 8.0.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by mnislaih): But surely if we had `SomeExceptionWithCallStack` then both 1) and 2) are available options, they are not mutually exclusive, right ? You could choose to apply 1) to IOError and leave the other exception types untouched, applying 2) where viable. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/12096#comment:10 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#12096: Attach stacktrace information to SomeException -------------------------------------+------------------------------------- Reporter: ndtimofeev | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Core Libraries | Version: 8.0.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by mnislaih): After thinking a bit more about it, I've realised why the `SomeExceptionWithCallStack` approach doesn't work well with the per- Exception type CallStacks: we end up with two CalltStacks stored in the same exception. Now I understand why C# and F# have special primitives for `rethhrow` .... -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/12096#comment:12 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#12096: Attach stacktrace information to SomeException -------------------------------------+------------------------------------- Reporter: ndtimofeev | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Core Libraries | Version: 8.0.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by ezyang): I know that `catchIO` and then `throwIO` if the `IOError` does not match a predicate is a common idiom. It's somewhat difficult to regex for them but if you grep for `throwIO` with a reference to a variable, there are tons and tons of them. Here are three random ones I picked out: {{{ -- system-fileio removeTree root = do items <- listDirectory root forM_ items $ \item -> Exc.catch (removeFile item) (\exc -> do isDir <- isRealDir item if isDir then removeTree item else Exc.throwIO (exc :: IOError)) -- HsSVN do err <- wrapSvnError =<< _fs_commit_txn conflictPathPtrPtr reposPtr newRevPtr txnPtr poolPtr case err of Nothing -> liftM (Right . fromIntegral) (peek newRevPtr) Just e -> if svnErrCode e == FsConflict then return . Left =<< peekCString =<< peek conflictPathPtrPtr else throwIO e -- DPM (Darcs.Lock.withLock fname (writeIORef ref True >> io)) `catch` (\ (e::SomeException) -> do b <- readIORef ref if b then throwIO e else failIO ("Could not obtain lock " ++ show fname ++ ", aborting.")) }}} I just grepped for `throwIO` and picked out three random examples that looked like they were rethrowing. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/12096#comment:14 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#12096: Attach stacktrace information to SomeException -------------------------------------+------------------------------------- Reporter: ndtimofeev | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Core Libraries | Version: 8.0.1 Resolution: | Keywords: Exceptions Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by bgamari): For what it's worth, I've collected some rather related thoughts (but in reference to DWARF stack traces) on wiki:Exceptions/StackTraces. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/12096#comment:16 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#12096: Attach stacktrace information to SomeException -------------------------------------+------------------------------------- Reporter: ndtimofeev | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Core Libraries | Version: 8.0.1 Resolution: | Keywords: Exceptions Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by ndtimofeev): We can substitute `?callStack` in `catch` from actual value to value from caught exception value. {{{#!hs catch' :: Exception e => IO a -> (HasCallStack => e -> IO a) -> IO a catch' eval handler = eval `catch` \err@(SomeExceptionWithStack stack _) -> let ?callStack = stack in case fromException err of Just ex -> handler ex _ -> throw err }}} Now all `throw` called from `catch` handler will be implicit rethrow. It looks like a ugly hack and required Rank2Types. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/12096#comment:18 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#12096: Attach stacktrace information to SomeException -------------------------------------+------------------------------------- Reporter: ndtimofeev | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Core Libraries | Version: 8.0.1 Resolution: | Keywords: Exceptions Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by simonmar): I quite like the idea of adding the call stack to `SomeException` actually. A lot of rethrowing operations already do the right thing, e.g. `catchJust` works: {{{ catchJust p a handler = catch a handler' where handler' e = case p e of Nothing -> throwIO e Just b -> handler b }}} So does `onException`, and the things that use it (`bracket` etc.) {{{ onException :: IO a -> IO b -> IO a onException io what = io `catch` \e -> do _ <- what throwIO (e :: SomeException) }}} So the places that don't work are those places that are using bare `catch` and re-throwing a more specific exception after doing some filtering on it. For those we should recommend using `catchJust` when possible, and perhaps provide alternative APIs that allow more expressive filtering. In the meantime there will be some places that get the wrong call stacks, but too bad - this is a debugging feature and as such doesn't need to be perfect. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/12096#comment:20 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#12096: Attach stacktrace information to SomeException -------------------------------------+------------------------------------- Reporter: ndtimofeev | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Core Libraries | Version: 8.0.1 Resolution: | Keywords: Exceptions Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by ezyang): OK, well, don't let me stop you guys from adding CallStack to SomeException :) -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/12096#comment:22 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#12096: Attach stacktrace information to SomeException -------------------------------------+------------------------------------- Reporter: ndtimofeev | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Core Libraries | Version: 8.0.1 Resolution: | Keywords: Exceptions Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #13372 | Differential Rev(s): Wiki Page: | Exceptions/StackTraces | -------------------------------------+------------------------------------- Changes (by bgamari): * related: => #13372 -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/12096#comment:24 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#12096: Attach stacktrace information to SomeException -------------------------------------+------------------------------------- Reporter: ndtimofeev | Owner: (none) Type: feature request | Status: new Priority: normal | Milestone: Component: Core Libraries | Version: 8.0.1 Resolution: | Keywords: Exceptions Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: #13372 | Differential Rev(s): Wiki Page: | Exceptions/StackTraces | -------------------------------------+------------------------------------- Changes (by saurabhnanda): * cc: saurabhnanda (added) -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/12096#comment:26 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler