https://github.com/microsoft/terminal/search?q=Telemetry%3A%...
https://github.com/microsoft/terminal/blob/main/src/host/tel...
https://github.com/microsoft/terminal/search?q=Telemetry%3A%...
https://github.com/microsoft/terminal/blob/main/src/host/tel...
Practically any Android app these days would be considered "spyware" if we were still applying the "spyware" definition of the early 2000s. And we would be better off if we had never stopped.
They are entitled to ABSOLUTELY NOTHING beyond, if it is commercial software, my payment.
I want them to know
What the fuck happened to just TELLING THEM!? Oh, that's right, they didn't want to listen because they'd rather take complete control of your machine, forcing you into what they want, and monetising every last aspect of "your" life, all the while hiding behind the excuse of "the data says" to do what they want.
The amount of pro-spyware comments here is, quite frankly, excruciatingly abhorrent. So many comments here smell strongly of corporate propaganda, since they also always repeat the same tired talking points --- and it makes me wonder how much shillage MS does. Or how many others think that because MS is big and "successful", they should emulate the increasingly abusive behaviour that it (and to be fair, the rest of Big Tech) engages in.
People don't say anything. They use the software, and then when features are deprecated they come screaming for you to continue supporting it. It's a waste of resources if they have to create an 'RFC' for every time they want to deprecate a feature due to development workload, when they could just have it report usage of features within the app. It's literally just how many people use specific features in the code they're writing; they're not watching what you type, they're not uploading a log of window titles like early blizzard anticheat software[0]. If you don't want them to be able to make informed decisions about the software they write you shouldn't use it, just create your own and send out a yearly/quarterly survey asking people to tell you what features they use, and see just how many people respond (hint: 30% of users is an unlikely best case scenario for external surveys[1]); hopefully that sample is good enough to drive decision on what features you stop supporting and what features to focus on.
0: https://www.eff.org/deeplinks/2005/10/new-gaming-feature-spy...
1: https://peoplepulse.com/resources/useful-articles/survey-res....
The problem is that, if it's not that now, it will, or at least might, be that eventually. It's a lot easier to make sure that an app isn't phoning home at all, than that it's phoning home with only approved information.
For example, it's a huge problem with browser extensions that, even if they start off well designed to respect a user's privacy and to gather information only in ways that are essential to their function, and that even if the original developer remains true to that mission, still if the extension becomes popular the developer will be prey to a lot of pressure from bad actors who want to buy the rights to the extension precisely so that they can expand the data-gathering into the realm that you implicitly acknowledge is unacceptable.
The makers of an app are entitled to no more information about me and my use of it than I allow them to have. I think that it's reasonable to argue whether my allowance of sharing should be opt-in or opt-out, but I don't think that there is much scope for argument about whether I should be able to block the sharing of information if I choose explicitly to do so.
(One could argue that, as long as everything is disclosed up front, then the makers of an app have the right to demand whatever they want, and I have the right to accept their demands or else not to use their software. This is surely true in one sense; but, in another sense, it's exactly what the notion of "contract of adhesion" is meant to describe, and in many other contexts it's recognised as not a good thing.)
To the argument that the makers of app can use telemetry information to make their app better, I would say that that is doubtless true; but I would argue that is also true that I, and not they, have the right to decide where the boundary lies between my desire for privacy and their desire to improve their app. For example, perhaps—even likely—browser makers could make their browsers better if they knew exactly what sites I visited, but, if I found my browser reporting my history information back to Mozilla, then I would not say "ah well, as long as it makes for a better browser."
Malware is more broad, and includes things that don't send any information back, like viruses.
Telemetry is spyware with a marketing department.
https://github.com/microsoft/terminal/blob/57c3953aca49f68ac...
https://github.com/microsoft/terminal/blob/2b202ce6d99340401...
ETW is explicitly opt-in on windows and is almost exclusively used for debugging, not to mention it requires a kernel mode driver to be loaded.
https://nasbench.medium.com/a-primer-on-event-tracing-for-wi...
I have not read all the code, but from a brief overview this tracing behavior and telemetry wouldn't be automatically activated anywhere except on Azure.
1. It looks like ETW is enabled by default since Vista.
2. The code deletes the username due to "PII issues," suggesting that something is being sent back (line 295)
3. An oblique reference to a 5% sampling rate (line 284) suggests you may not be able to tell what it's sending based on network monitoring.
Apparently they are considering stopping collecting the list of processes due to "community consternation" but have not yet: https://github.com/microsoft/terminal/issues/6103
They could at least document what they collect so we aren't left guessing. https://github.com/MicrosoftDocs/terminal/issues/139
All that said, it is legitimately great that the source code and these issues are available publicly.
This issue seems to fully explain the issue with the telemetry: https://github.com/microsoft/terminal/issues/5331
The biggest takeaway to me here (besides the explanation of the telemetry levels) is that the processes in question are cmd, powershell, bash, etc, and not what you are running in them. Even if you have enhanced telemetry enabled it wouldn't bubble up what you're running underneath the console process as a process name.
Imagine if every .exe and every .dll did that! That's not OK!
With web applications every single round trip to the server is logged, inherently, and there are far more than one round trip to the server than there are page loads, I assure you. So it's ok there? "oh that's just logging, not telemetry." That's what telemetry is!
Google and Facebook track you (collect telemetry on you) across the entire web whether or not you use Google or Facebook AT ALL, and they each collect more information than Microsoft ever could. Google and Facebook do far worse things than Microsoft has ever done, but because they didn't ship a browser with their OS in the 1990s, they get a pass on everything, apparently.
I don't get it. the lies we tell ourselves are worse than anything anyone else could ever do to us, but we tell them to ourselves anyway because it is acceptable to crap on Microsoft, for imaginary reasons, and it isn't acceptable to crap on the companies doing the real bad stuff.
humanity is doomed. we are literally a garbage species.
- it's more work when you're trying to stop
data exfiltration / espionnage
- privacy -- I've no idea what the telemetry
says about me today, and I certainly don't
know what they'll make it look for tomorrow
- privacy -- even if the telemetry is fine,
maybe information about my usage patterns
might be more valuable to me than it might
seem at first glance
- performance -- every app, every library, all
sending out telemetry? Please, no.
- because I get to not want thisyou keep on living in your town where the people don't have fingerprints or names, and the shoes leave no tracks. I'll be over here getting things done, because doing good work is far more important than avoiding being seen.
the performance argument is solid and I will see if I can measure that before I agree with you.
from what I've read, at least among the common telemetry systems I know of (Azure Application Insights, OpenTelemetry, and Microsoft's system built into the OS), telemetry is gathered for a bit then sent in a batch, which would indicate that performance is at least a consideration.
With a website, you can control what you do where. If your terminal client is sending stuff to the sky, you never know what it’s actually doing.
it's all plain JSON, too.
but people still bitch endlessly about "spying" and foam at the mouth (literally) while they yell about it, acting like they know everything about the situation.
[0] https://docs.microsoft.com/en-us/windows/privacy/diagnostic-...
Asking for feedback doesn't work because that inflates the vocal minority.
Awful.
Maybe quit using file extensions instead of calling things libraries and executables?
But seriously, since Microsoft is sharing the source code, why not just remove the unwanted telemetry and re-compile.
How easy would that be.
1 : [intransitive] to collect secret information about another country, organization or person
If you feel like a bunch of developers getting info about how many times the world clicks on a button hurts you personally, then don't install it. Calling it a privacy issue it taking it too far.
I love windows terminal, but it should collect nothing by default. Another subjective opinion.
And yes, I think that an HTTP POST to Microsoft's Windows Terminal team saying "UserUsedTerminalInInterative = true" is not a privacy issue, nor is it spying.
Can you explain to me how this information hurt users of Windows Terminal? If it indeed is spying, it should be possible to demonstrate how it is used for hostile purposes or why such an innocuous piece of information must be kept a secret.
Until then, I think it is fair for the Windows Terminal team to collect such basic telemetry for their software
Yes, words have meanings.
Company A May decide telemetry exposes too much internal information to a potential competitor.
Company B May decide that telemetry does not release anything they want kept secret.
Those are subjective opinions. If I want the data to be kept secret and somebody takes it without my explicit approval, that is a privacy violation. If I don’t care, it’s not. Same thing with spying. If I deem it a secret, it is now spying to take it from me.
No it isn't.
The word "spy" has a very specific definition, that you'd have stretch pretty far to include any of the data collected by the Terminal app.
That is the definition of spying.
You know most of what an actual spy collects isn’t super secret stuff right? Aggregated unclassified information can still reveal secrets.
Nothing. Nothing at all.
It’s very easy to de-anonymize telemetry data, track users across IP addresses, collate with other application’s telemetry data, determine which users are in the same places at the same time, and generally extract a huge amount of data about people, who they spend time with, where they spend time, and what they do there.
Telemetry is unequivocally spyware.
It feeds a firehose of data to the internet, and both data brokers and state actors do absolutely everything they can to gobble it up.
I think some people will have a hard time with this concept, but the idea of data being “private” or “secret”, by default, is disappearing. And it won’t be coming back if the world continues to digitize.
If you want those attributes for your data, you’ll have to take measures. That means reading user agreements, verifying open source, using encryption intentionally.
Vacuuming up data is not spying. Especially if you essentially agree to it when you accept the Windows terms of service (ethical issues of this aside).
“But the plans were on display…”
“On display? I eventually had to go down to the cellar to find them.”
“That’s the display department.”
“With a flashlight.”
“Ah, well, the lights had probably gone.”
“So had the stairs.”
“But look, you found the notice, didn’t you?”
“Yes,” said Arthur, “yes I did. It was on display in the bottom of a locked filing cabinet stuck in a disused lavatory with a sign on the door saying ‘Beware of the Leopard.”
I wish there was way everywhere to collect with privacy and being accepted by user as not something we want to spie people on... but as always there is (a lot ) of abuse in this area so this may never going to happen
Has anyone tried just showing people the information the application would like to report back? I know it's been tried with crash reports.
No, actually, on account of being a software dev, I know that telemetry is actively counterproductive when making decisions on how to make things. It makes your decisions more wrong, not less.
even as OSS software maker, would you start working on features because they are "cool" or a bunch of people yelling^H^Hasking for it on twitter?
I assume it's yet another case of the fallacy of revealed preferences.
If you look at what people actually do, any insight into what they want is confounded by environmental effects (eg, they'd prefer to use feature A, but feature A is missing or inconvenient to access, so they end up mostly using feature B), selection bias (feature A is most useful to precisely the people who know how to turn off or deliberately break telemetry), and other issues (A/B testing confirms that people have a revealed preference for clicking on animated icons (because they're trying to make the fucking thing stop squirming in their peripheral vision while they're trying to concentrate on something else)).
(Talking with users is definitely possible (usually easy) to screw up, but I have yet to encounter any evidence that it's possible to not screw up telemetry-based design decisions by any means other than ignoring the telemetry.)
There are real costs to not being able to trust your own local computer and personal information. History is rife with examples, from IBM and internment during WWII to the malware and NSA of modern times. Data is no longer deleted.
Let's take a look at `windowio.cpp` for example. This most-generic event fires every time you type any input character on the keyboard: https://github.com/microsoft/terminal/blob/57c3953aca49f68ac...
It also has more-specific events for several different ways of selecting, copying, and pasting text: https://github.com/microsoft/terminal/blob/57c3953aca49f68ac...
In `find.cpp` we can see it log every time you find the next result in the "Find" dialog, as well as when the dialog is closed: https://github.com/microsoft/terminal/blob/57c3953aca49f68ac...
In `windowproc.cpp` we can see it log every time you resize a console window, close a console window, bring up the context (right-click) menu, drag-and-drop on to a console window:
- https://github.com/microsoft/terminal/blob/57c3953aca49f68ac...
- https://github.com/microsoft/terminal/blob/57c3953aca49f68ac...
- https://github.com/microsoft/terminal/blob/57c3953aca49f68ac...
- https://github.com/microsoft/terminal/blob/57c3953aca49f68ac...
This even extends outside the "Terminal" application wrapper itself, with a generic "LogApiCall" used to track e.g. any time any other process spawns a console window:
- https://github.com/microsoft/terminal/blob/57c3953aca49f68ac...
- https://github.com/microsoft/terminal/blob/57c3953aca49f68ac...
Click around a few of the search results and see what else you can find!
For all the folks who say it's all totally innocuous (or even beneficial). Even if it is, I can tell you, I have no interest in my computer doing this while I'm using it.
Every time I rebuild my laptop it has these “mysterious” slowdown periods that force me to dig through the metrics to see what is the culprit.
About 80% of the time it’s telemetry.
The worst one is actually the Intel driver installer which has telemetry that is so far beyond obnoxious that it’s an embarrassment to every so-called “engineer” involved.
Shame.
Shame.
Each of the calls you link to sets a boolean here: https://github.com/microsoft/terminal/blob/57c3953aca49f68ac...
It does not transmit what you copy, search for or when you clicked/resized/closed the window. It simply stores a true/false value saying "feature X was used". In some cases, like with find/replace, it also stores the average length of things you searched for. That is a common way for developers to get an idea if performance characteristics due to the longest common substring problem[1]
You are trying to spread misinformation here to make Microsoft look like a bad guy. There is nothing sinister going on here, it is just ordinary metric collection.
But don't take my word for it. Take for example the "we can see it log every time you resize a console window" statement. In the link it calls SetWindowSizeChanged()[2] which again calls SetUserInteractive()[3] and it just sets a boolean to true.
So there is no "log every time it resize a console window". It simply sets a variable to true, which presumably the Windows Terminal dev team use to see how many users use the console with interactive sessions.
[1] https://en.wikipedia.org/wiki/Longest_common_substring_probl...
[2] https://github.com/microsoft/terminal/blob/57c3953aca49f68ac...
[3] https://github.com/microsoft/terminal/blob/57c3953aca49f68ac...
Inevitably mistakes are made that either slow down computers or outright freeze apps that can’t connect to some telemetry endpoint.
Security teams around the world feel like they’re holding back the tide with a broom because EVERY piece of software is contributing to a veritable firehouse of information sprayed all over the Internet from every endpoint on the network.
This is not okay.
It’s not Microsoft’s computer.
It’s not their network.
It’s not their data.
How is this not clear?
How can you be so apologetic?
You are running an operating system made by Microsoft, they could monitor how often you click your mouse just like every website on the planet at this point but dont. Boolean telemetry on feature use is somehow the end of the world? Get out.
In effect, ONE application has at least four independent sets of telemetry.
This is the console, the kind that you would use on servers. High-security servers in DMZs. Servers hosting police records, health records, or even military secrets.
FUD my arse. It's a torrent of information that seeks every crack it can find to "get out", purposefully designed to circumvent mitigations by security teams.
Two examples: Microsoft regularly changes which environment variables disable telemetry. Just about every major release means that I have to check if it is now "DOTNET_TELEMETRY=Off" or "NET_TELEMETRY_CORE=0" or whatever. This isn't an accident. Nobody's "finger slipped". The old telemetry started to tail off and someone "fixed it" in Microsoft to get 100% coverage, against the will of their privacy concious customers.
Similarly, some Windows telemetry uses "microsft.com" instead of "microsoft.com" to bypess firewall rules blocking the latter.
You can't tell me that this is "nothing to worry about" when it feels an awful lot like the enemy is inside the gates and is actively hostile to any measures taken to stop them progressing further into the network.
In the case you mention, it should be IMO up to you to prevent this, probably via firewall.
Having standard telemetry environment variable might be for the best. There is a risk in this case to disable telemetry systematically though, even if you want to just block it in one app, which is also not something I as vendor of many tools would want.
This is probably not easy to fix for everybody to be happy. And its probably not that important for security - there are FAR easier way to deduce something about someone then to 1) hack microsoft telemetry servers or transit 2) look into the patterns of use of specific programs. Besides, telemetry data is anonymous. So I guess even in the case you get the data, what could you do with it ? I can send you billion of telemetry data of government services I make, you can only deduce that people start working at 7AM and get lots of passwords wrong before first coffee.
I have plenty of environments that run whitelist only, you can always go that route and not think about any vendor, any software not getting out.
And stuff like this is just inflammatory:
>Similarly, some Windows telemetry uses "microsft.com" instead of "microsoft.com" to bypess firewall rules blocking the latter.
Do you think we'd just block *.microsoft.com over their telemetry domain, microsft.com? Half the planet is in O365.
And on the flip side you know we'd all block telemetry.microsoft.com just because, it wouldn't matter what they collect and not think twice, then turn around sell it to people as "we are adding security".