This is something I've been wondering myself and the answers here so far have been wonderful. I'm gunna add something different. I'm guessing you're a programmer, so I think you might like to think about it like a programmer and consider this question a question of corpus linguistics. I dunno if Ruby has an NLP package (like Python's NLTK) for Japanese but if it does and you know how to use it, then you pretty much have an answer to your question. Answers here could only tell you which textual domains are trustworthy for low error rates and will likely not lead to mistraining (newspaper articles, google blogs, etc), which domains have notoriously high error rates which will lead to mistraining (youtube comments, etc) or what the most common types of errors actually are by listing them. But if your goal is to avoid mistraining while you read text in your browser, then your only task is to not fail in identifying errors. So really you should be thinking about how to identify errors given that you can't do it yourself because you're not a native speaker.
"Am I likely to pick up bad spelling or grammar from Japanese that is written by native speakers but isn't professionally written" In short, no. For the grammatical errors, they are just as abundant in English as in Japanese as in French as in etc. Unless you can explain why a Japanese native is more or less likely to make a grammatical error than an English native? So if you trust the English ruby dev mailing list, then for all practical purposes there is no reason not to trust the Japanese dev mailing list.
I'm guessing basically that your question is one of likelihood: "how common are grammatical errors" and "how common are spelling errors" where spelling is using the wrong kanji or mistyping. If avoiding mistraining is your goal, then to achieve that you only need to correctly identify errors.
For the spelling, just copy a representative text sample and past it into a word processor like Word with Japanese spell check on and see how many red squigglies appear. Add or subtract from the dictionary on specific instances to train the spell checker. You can literally get an approximate numerical answer to "how likely" a spelling mistake is given the specific textual domain, such as a mailing list or newspaper articles in like 20 minutes. If there isn't a spell checker then use Kuromoji.
Spelling errors aren't as straightforward as grammatical errors. The ideal way to test for grammaticality is get a census from natives not a yes/no boolean value. There should be a census on what qualifies as a blatant grammatical error, so for example using the wrong preposition "print down a paper" instead of "print out a paper" should have near 100% agreement from native speakers. But something like "me and Bill" instead of "Bill and I" no doubt receives a more fragmented census. So just create an index, then you decide based off scores on the index whether or not that's something you want to adopt and internalize. For example things higher up on the index are more reliably safe to learn yourself.
For starters, the most unacceptable grammatical errors would be easy to candidatentially identify, because they are by definition rare and so you don't expect them to occur systematically. So in English the phrase "The children never have waited" would occur infrequently in a corpus relative to the phrases "The children {will/must/couldn't/should} have waited" which tells you it could be an error. The larger the corpus the more evidence you will have in favour or against that hypothesis.
Looking at frequencies to identify erroneous constructions would have to be supplemented by parsing the text. With a syntax tree you could compare it to a syntax model of Japanese to compute whether or not it's derivable. Use a string metric, such as the Levenshtein distance, to define the distance from a 100% grammatically correct syntax to get an index of "ungrammaticality". Depending on how many rules you have you can make very minute definitions on what is acceptable grammar. You should be able to do all this on an NLP package.
If your corpus is something like Youtube comments, there is still something you can learn from them. It seems that most comments are in sentence fragments and inconsistent with punctuation. So you can't learn anything above the phrase level from Youtube. That still leaves things like collocations (frequent word pairings) to learn. A lot of what natives think is grammatical is actually just collocational. When you ask a native if something is grammatical and they say yes but tell you not to say it because people just don't say it, then the thing in question is in reality probably just a collocation, so if you want good language habits, you need to learn collocations.
In terms of practical learning and not just theory, what I think you would want to do is write a text filter, maybe in Javascript with TinySegmenter or something, so that you could visit a website, run the Javascript, and use a color scheme (that corresponds to the computed index) to highlight text that, according to your script, deems bad grammar. Red for the blatant unquestionable errors, orange for errors that are more tolerable, etc. The point is to identify errors on the page as you read the text. If this is done, then there's no risk of mistraining.
