Develop Reference

Logcat is being "spammed", resulting in "Too much output to process"

Whenever I connect my Samsung Galaxy S5 (running Android 4.4.2) to my computer, the Logcat in Android Studio starts being "spammed" by the same message multiple times ~1600 times per second, resulting in the message "Too much output to process" appearing in a yellow box in Logcat. This is when there is no filtering and no debug process selected.
The Logcat message is this:
D/tms_audio_hw/AudioTmsIpc AudioTmsClientListen accept Done gAudioClientAcceptSockFd -1 gAudioClientLocalSockFd 24
Googling it reveals surprisingly little. Actually nothing. I'm not sure, but it seems to be affecting the logging from my application as well, because when I select my application as the debug process, I don't get all the Logcat outputs from my application - sometimes I'll get some, sometimes I'll get others, sometimes I'll get none.
Also, because of this my computer starts using CPU like crazy just to process those messages, resulting in extreme CPU usage and fans at full blast!
What the heck is causing this?
EDIT
I have now looked at exactly how fast these logs are coming in, and it's at a rate of 1600 logs per second, and it's just this same message over and over and over. Don't tell me this is "normal behaviour" unless you are experiencing this on your own devices.

You may have selected "No Filters" in android monitor which causes "Too much output to process error", Change it to "Show only selected Application" then all other Log line are filtered and will not show in Logcat.
Here is snapshot of Android Monitor.

I had a similar problem while testing an app. Initially the log messages displayed as expected and then it started to display my log messages "at random", i.e. showing and then not showing.
Removing the Logcat filter showed the "too much output to process" message. I also noticed that the log was displaying messages relating to apps installed on my phone (I was using a phone to test my app) and had nothing to do with my app.
I disconnected the phone from my laptop, restarted the phone and then re-connected it back to the laptop and ran the app. The Logcat was back to normal, showing the log messages as expected.

That is normal behaviour; it is not related to a particular phone model or Android OS version. When you remove all filters, there's just too much logging output being redirected from everything that can and does log, including system components and various libraries that are loaded at that time.
The recommended default approach is to simply filter out and view only your application's log output and switch to no filtering only when you are specifically debugging something where you need to know what else is happening around that part of code.

why does logcat drain messages

When I test my android app, I log messages that show up on LogCat. But the messages drain out the top of the window quickly making it impossible to read them quickly enough.
How can I stop this?

There's a scroll lock in the logcat window that you can use to pause the printout for a moment.
To get complete logcat messages, you can redirect them to a file:
adb logcat >& output.log

It depends somewhat on what you mean by "drain". If the problem is simply that messages are scrolling by too fast and you need to stop auto-scrolling to the bottom, you can pause this feature in the IDE (or in DDMS/Monitor). HOW you pause it depends on your IDE, in IntelliJ you can just click somewhere in the log output to place a cursor, and in Eclipse there is a button above the logcat window to pause the output scrolling (don't forget to turn it back on or you won't see new messages).
However, if your problem is that so much data is being logged that you cannot scroll up to see what you need even if scrolling is paused, you need to log less. This is because the Android logcat driver is a fixed-size 64KB circular memory buffer. So if you log enough data, it will begin to overwrite the older entries in the log and they will be gone before you've had a chance to read them.

There are some methods:
Disable the auto scrolling feature. Click on the "Scroll Lock" button to disable this.
Use the command line tools. Run "adb logcat | less" and you can navigate for the results. You can also run "adb logcat > logcat.txt" and inspect logcat.txt after that.

Why don't you filter the logcat, so it shows the things your are most interested in.
You can display only the tags you are interested in with the following syntax (using the adb tool from the command line - also available in the logcat view in Eclipse):
adb logcat TAGTOSHOW:* TAGTOSHOW2:* *:s
You can include as many TAG combinations as you want. Don't forget the *.s which silences all the rest.

I prefer teeing to a file:
adb logcat | tee foo.log | grep "YOUR_TAG_OF_INTEREST"
This way you get whatever you think you're looking for in your terminal window, but if you need to look at the full logs you have them saved off in a file.

Logcat output of my app vanished from logcat output

i have a problem with logcat output of my app:
Normally logging to logcat works. But at some times my app's output seems to be entirely removed from the logcat output. Though i can prove that the app logged, there is not a single line in logcat.
When does this happen:
I shedule my app to wakeup at midnight by a BroadcastReceiver starting a Service. The app wakes up and creates a logfile, writes to that file and to logcat in parallel by calling a function which writes to both. The logfile contains 3 lines written. (and then the app somehow dies.) At least these 3 lines have been also logged to logcat.
Next day i display all logcat messages, which encloses midnight. Not a single line logged for my app.
I think Android has purged my App from memory and at midnight it is loaded again (and crashes because it is not initialized properly). But why is there no logcat output?
thanks for your hint.

Logcat has a size limit. Once this limit is reached, older messages are purged to make room for the new ones coming in. It's not that Logcat is removing your app's messages specifically, it's that in the course of running over night there are so many other messages going to Logcat that yours are being removed.
To see the buffer size on your specific device, plug it in and execute the following command in a shell window:
adb logcat -g
If you need to collect log messages at a time where you can't physically be looking at the output window, you're doing the right thing by logging to a file. I do something similar where I'll set a global flag on the build that tells it whether to log normally or output to a local file on my phone.

Strange logcat filter behaviour

Sometimes I am on the lookout for specific logcat messages for debugging purposes and its critical to see exactly when they appear. I then make a logcat filter (call it xx) in eclipse ready to spot the critical message. I then highlight the xx filter and run my app and look out for my message - nothing appears in my xx filer view - but I notice increasing numbers win brackets next to the "All messages (no filters)". If I then click on the All messages thing and then go back to xx then hey-presto my messages are visible. Its almost as if eclipse is determined never to let me see these messages as they arrive. Is there anything I can do about this?

I've found that part of the eclipse plugin very unreliable, especially if there are a high volume of log messages it is prone to making the whole window slow / freeze.
Personally, I tend to run logcat in a shell, sometimes piped into grep
tee can also be useful, to write a copy to disk for later examination.

Make sure that logcat isn't paused.

Logcat in eclipse keeps auto clearing

until recently my logcat has been fine but all of the sudden whenever i try to view it in eclipse it just keeps clearing itself whenever anything is displayed making it impossible to read. viewing it in the adb works but I never bother with that since it is just such a pain to read and find anything you are looking for.
is there a way to fix this problem?

The Logcat messages were simple getting cleared because the buffer had run out of space (receiving too many new messages), which is a simple setting change in Eclipse.
To fix, go to Window > Preferences > Android > LogCat
and increase the limit for "Maximum number of LogCat messages to buffer". Set it to 0 for unlimited size, or a really big number. But keep in mind, anything below 10000 fills up real fast.
Been answered already:
Eclipse Android - Logcat Clearing too Fast

It will show one line before erasing it to show the next one? Just click the verbose button again.

There's a workaround for this bug. Click active mode button (usually verbose), choose another device from device list and choose previous device again. It will restore all logcat messages.

LogCat is really annoying for this. In Ubuntu, I found the following works really well:
Open a terminal and type adb logcat | grep MYINFO
This will only show adb messages filtered by the MYINFO string.
So, you can code something like:
Log.v("MYINFO", "x" + x_value + ", etc...");
This is such a relief to use. A life saver! See this for more info.
You may find sometimes the logcat buffer repeats previous logs on starting again. To overcome this, type
adb logcat -c