Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Create throttling measurement methodology #1296

Open
2 of 5 tasks
bassosimone opened this issue Nov 18, 2022 · 3 comments
Open
2 of 5 tasks

Create throttling measurement methodology #1296

bassosimone opened this issue Nov 18, 2022 · 3 comments

Comments

@bassosimone
Copy link
Contributor

bassosimone commented Nov 18, 2022

This issue is about creating and adding a throttling measurement methodology to ooniprobe. The general idea to move forward is build upon our recent throttling measurements in Russia.

@agrabeli
Copy link
Member

For more context, this is what is written in our DRL proposal:

Bandwidth throttling is commonly being reported around the world (particularly during elections and large-scale protests), but an open methodology for measuring it in an automated way from local vantage points does not exist yet. Last year, we collaborated with Censored Planet on measuring the throttling of Twitter in Russia, but this was the result of manual tests run by in-country volunteer technologists and included the analysis of packet captures.

As part of this activity, we will implement a new open methodology for measuring throttling that will be shipped as part of the OONI Probe apps and run automatically from local network vantage points (without requiring any technical expertise from the user, nor the collection of packet captures). This will enable our global community to automatically measure throttling every day and contribute measurements as open data in real-time, supporting the efforts of advocacy groups worldwide (such as the global #KeepItOn campaign).

We have already started experimenting with some possible approaches for measuring the presence of bandwidth throttling. We recently, for example, investigated the throttling of Twitter in Russia amid the war in Ukraine through the analysis of data already present in OONI measurements. Through our analysis, we were able to infer that Russia’s throttling infrastructure appears to be centrally managed.

We plan to further systematize the collection and analysis of throttling-related information to detect this form of censorship at scale. In developing our methodology, we plan to collaborate with our partner, the Internet Outage Detection and Analysis (IODA) project of Georgia Tech, who are also planning on extending their platform to measure the presence of bandwidth throttling. OONI and IODA datasets and measurement approaches are different, and will therefore be complementary, offering richer insight into bandwidth throttling.

@agrabeli
Copy link
Member

I have set a tentative timeline on zenhub which probably needs to be adjusted.

@bassosimone
Copy link
Contributor Author

bassosimone commented Mar 9, 2023

Here's additional contextual information from: ooni/probe#1680

Over the years, community members have frequently expressed the need for a new nettest designed to measure throttling. This was also more recently requested during RightsCon sessions.

Currently (to my knowledge), an open methodology for measuring throttling doesn't exist yet, and defining and measuring throttling remains an ongoing research question.

Some things to take into consideration:

  • What do we mean by throttling? Are we referring to throttling towards specific services? We first need to come up with a specification and based on that evaluate which methodology makes sense (and is feasible).

  • Community members frequently report throttling towards popular social media services, such as Facebook, Twitter, YouTube, Instagram, etc.

  • Sometimes community members also report "generic throttling" to communicate unusually slow internet speed (without being specific to services). However, these reports often emerge during protests and other events, when it's possible that this could be explained by network congestion and other factors.

Currently, we have the NDT and DASH tests which are run against M-Lab servers. However, these tests are not sufficient for measuring throttling because:

  • We don't have a baseline to compare these measurements against;

  • These tests are usually user-initiated, and there is often testing bias involved (i.e. people often only run tests when they notice that their internet connectivity is unusually slow, instead of running them all the time).

We would ideally need a large volume of stable measurements (collected from the same AS network) over a long period of time in order to be able to derive statistically-useful information. While the OONI Probe apps support automated testing, the NDT and DASH tests are (currently) not included in automated runs because that would be too bandwidth-intensive. So it remains quite unclear how to collect large volumes of stable measurements from user-initiated tests.

If we were to measure throttling towards a specific service (e.g. Facebook), we would need that company to host a measurement backend that we can run tests against. In this scenario, the OONI Probe DASH test (for example) would run tests against M-Lab servers + Facebook's measurement backend. That way, we would be able to compare the 2 measurements in order to be able to start measuring potential throttling. Convincing companies to host such a measurement backend though can be challenging.

I am going to close ooni/probe#1680 because it's been superseded by this issue, but I also wanted to include the original Epic text to have all the context into the same place.

@bassosimone bassosimone changed the title Create throttling methodology Create throttling measurement methodology Mar 10, 2023
bassosimone added a commit to ooni/2023-05-richer-input that referenced this issue Jul 3, 2023
This diff improves the DSL for writing nettests introduced in
#5 such that we a
single homoiconic representation of the DSL. The internal DSL, written
in pure Go, could either perform a measurement directly or could be
exported to a JSON-based AST. The external DSL derives from the
JSON-serialized AST and runs the same operations as the internal one,
except that type checking happens at runtime.

Because the internal DSL is in pure Go, we don't need to write custom
code for type checking. At the same time, we have now lost the
possibility of having a polymorphic HTTP step and we need to cast a TCP,
TLS, or QUIC connection to become an HTTP connection by using the proper
operation.

All the other functionality should be compatible with
#5. Obviously, I needed
to change the JSON representation to accommodate for minor changes, so
the previously serialized JSONs should not be working anymore. This is
fine, since we're still in the experimentation stage.

To be more confident that dynamic type checking works, this PR added
comprehensive [netem](https://github.com/ooni/netem) based QA tests that
exercise the most common type conversions happening on success or error.

In terms of terminology, I also chose to replace "func" with "stage" (or
"stage_name") since it seems more selective to deal with the composition
of pipeline stages than with the composition of functions. (The pipeline
stages are functions but, by calling them pipeline stages, we further
clarify what we're dealing with.)

This work is part of ooni/probe#2494 and
ooni/ooni.org#1296. The latter issue is
related to this PR because we also included support for throttling to
the DSL.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Projects
None yet
Development

No branches or pull requests

2 participants