Adopt use of labels across metrics

    registry = CollectorRegistry()

    total_network_relays = Gauge('total_relays', 'Current number of relays on the network', registry=registry)

    total_network_relays.set(len(total_relays))

    online_network_relays = Gauge('online_relays', 'Current number of online relays on the network', registry=registry)

    online_network_relays.set(len(online_relays))

    offline_network_relays = Gauge('offline_relays', 'Current number of offline relays on the network', registry=registry)

    offline_network_relays.set(len(offline_relays))

    total_network_bridges = Gauge('total_bridges', 'Current number of bridges on the network', registry=registry)

    total_network_bridges.set(len(total_bridges))

    online_network_bridges = Gauge('online_bridges', 'Current number of online bridges on the network', registry=registry)

    online_network_bridges.set(len(online_bridges))

    offline_network_bridges = Gauge('offline_bridges', 'Current number of offline bridges on the network', registry=registry)

    offline_network_bridges.set(len(offline_bridges))

    total_network_obfs4_bridges = Gauge('total_obfs4_bridges', 'Current number of obfs4 bridges on the network', registry=registry)

    total_network_obfs4_bridges.set(len(total_obfs4_bridges))

    online_network_obfs4_bridges = Gauge('online_obfs4_bridges', 'Current number of online obfs4 bridges on the network', registry=registry)

    online_network_obfs4_bridges.set(len(online_obfs4_bridges))

    offline_network_obfs4_bridges = Gauge('offline_obfs4_bridges', 'Current number of offline obfs4 bridges on the network', registry=registry)

    offline_network_obfs4_bridges.set(len(offline_obfs4_bridges))

    total_network_moat_bridges = Gauge('total_moat_bridges', 'Current number of moat bridges on the network', registry=registry)

    total_network_moat_bridges.set(len(total_moat_bridges))

    online_network_moat_bridges = Gauge('online_moat_bridges', 'Current number of online moat bridges on the network', registry=registry)

    online_network_moat_bridges.set(len(online_moat_bridges))

    offline_network_moat_bridges = Gauge('offline_moat_bridges', 'Current number of offline moat bridges on the network', registry=registry)

    offline_network_moat_bridges.set(len(offline_moat_bridges))

    total_network_overload_general_relays = Gauge('total_overload_general_relays', 'Current number of relays in overload_general state on the network', registry=registry)

    total_network_overload_general_relays.set(len(total_overload_general_relays))

    total_network_overload_general_relays_version = Gauge('total_overload_general_relays_version', 'Current number of relays in overload_general state on the network per version', ['version'], registry=registry)

    network_relays = Gauge('total_relays', 'Current number of relays on the network', ['status'], registry=registry)

    network_relays.labels(status='all').set(len(total_relays))

    network_relays.labels(status='online').set(len(online_relays))

    network_relays.labels(status='offline').set(len(offline_relays))

    network_bridges = Gauge('total_bridges', 'Current number of bridges on the network', ['status'], registry=registry)

    network_bridges.labels(status='all').set(len(total_bridges))

    network_bridges.labels(status='online').set(len(online_bridges))

    network_bridges.labels(status='offline').set(len(offline_bridges))

    network_transport_bridges = Gauge('total_transport_bridges', 'Current number of bridges per transport on the network', ['status', 'transport'], registry=registry)

    network_transport_bridges.labels(status='all', transport='obfs4').set(len(total_obfs4_bridges))

    network_transport_bridges.labels(status='all', transport='moat').set(len(total_moat_bridges))

    network_transport_bridges.labels(status='online', transport='obfs4').set(len(online_obfs4_bridges))

    network_transport_bridges.labels(status='online', transport='moat').set(len(online_moat_bridges))

    network_transport_bridges.labels(status='offline', transport='obfs4').set(len(offline_obfs4_bridges))

    network_transport_bridges.labels(status='offline', transport='moat').set(len(offline_moat_bridges))

    network_overload_general_relays = Gauge('total_overload_general_relays', 'Current number of relays in overload_general state on the network', ['status'], registry=registry)

    network_overload_general_relays.labels(status='all').set(len(total_overload_general_relays))

    network_overload_general_relays.labels(status='online').set(len(online_overload_general_relays))

    network_overload_general_relays.labels(status='offline').set(len(offline_overload_general_relays))

    network_overload_general_relays_version = Gauge('total_overload_general_relays_version', 'Current number of relays in overload_general state on the network per version', ['version'], registry=registry)

    for v in total_overload_general_relays_version.keys():

        total_network_overload_general_relays_version.labels(version=v).set(total_overload_general_relays_version[v])

    online_network_overload_general_relays = Gauge('online_overload_general_relays', 'Current number of online relays in overload_general state on the network', registry=registry)

    online_network_overload_general_relays.set(len(online_overload_general_relays))

    offline_network_overload_general_relays = Gauge('offline_overload_general_relays', 'Current number of offline relays in overload_general state on the network', registry=registry)

    offline_network_overload_general_relays.set(len(offline_overload_general_relays))

        network_overload_general_relays_version.labels(version=v).set(total_overload_general_relays_version[v])

    total_network_overload_general_bridges = Gauge('total_overload_general_bridges', 'Current number of bridges in overload_general state on the network', registry=registry)

    total_network_overload_general_bridges.set(len(total_overload_general_bridges))

    network_overload_general_bridges = Gauge('total_overload_general_bridges', 'Current number of bridges in overload_general state on the network', ['status'], registry=registry)

    network_overload_general_bridges.labels(status='all').set(len(total_overload_general_bridges))

    network_overload_general_bridges.labels(status='online').set(len(online_overload_general_bridges))

    network_overload_general_bridges.labels(status='offline').set(len(offline_overload_general_bridges))

    total_network_overload_general_bridges_version = Gauge('total_overload_general_bridges_version', 'Current number of bridges in overload_general state on the network per version', ['version'], registry=registry)

    network_overload_general_bridges_version = Gauge('total_overload_general_bridges_version', 'Current number of bridges in overload_general state on the network per version', ['version'], registry=registry)

    for v in total_overload_general_bridges_version.keys():

        total_network_overload_general_bridges_version.labels(version=v).set(total_overload_general_bridges_version[v])

    online_network_overload_general_bridges = Gauge('online_overload_general_bridges', 'Current number of online bridges in overload_general state on the network', registry=registry)

    online_network_overload_general_bridges.set(len(online_overload_general_bridges))

    offline_network_overload_general_bridges = Gauge('offline_overload_general_bridges', 'Current number of offline bridges in overload_general state on the network', registry=registry)

    offline_network_overload_general_bridges.set(len(offline_overload_general_bridges))

        network_overload_general_bridges_version.labels(version=v).set(total_overload_general_bridges_version[v])

    total_network_overload_ratelimits_relays = Gauge('total_overload_ratelimits_relays', 'Current number of relays in overload_ratelimits state', registry=registry)

    total_network_overload_ratelimits_relays.set(len(total_overload_ratelimits_relays))

    total_network_overload_fd_exhausted_bridges = Gauge('total_overload_fd_exhausted_bridges', 'Current number of bridges in overload_fd_exhausted state', registry=registry)

    total_network_overload_fd_exhausted_bridges.set(len(total_overload_fd_exhausted_bridges))

    total_network_eol_version_relays = Gauge('total_eol_version_relays', 'Current number of eol relays', registry=registry)

    total_network_eol_version_relays.set(len(total_eol_relays))

    online_network_relays_eol_version_relays = Gauge('online_eol_version_relays', 'Current number of online eol relays', registry=registry)

    online_network_relays_eol_version_relays.set(len(online_eol_relays))

    offline_network_eol_version_relays = Gauge('offline_eol_version_relays', 'Current number of offline eol relays', registry=registry)

    offline_network_eol_version_relays.set(len(offline_eol_relays))

    network_eol_version_relays = Gauge('total_eol_version_relays', 'Current number of eol relays', ['status'], registry=registry)

    network_eol_version_relays.labels(status='all').set(len(total_eol_relays))

    network_eol_version_relays.labels(status='online').set(len(online_eol_relays))

    network_eol_version_relays.labels(status='offline').set(len(offline_eol_relays))

    total_network_eol_version_bridges = Gauge('total_eol_version_bridges', 'Current number of eol bridges', registry=registry)

    total_network_eol_version_bridges.set(len(total_eol_bridges))

    online_network_eol_version_bridges = Gauge('online_eol_version_bridges', 'Current number of online eol bridges', registry=registry)

    online_network_eol_version_bridges.set(len(online_eol_bridges))

    offline_network_eol_version_bridges = Gauge('offline_eol_version_bridges', 'Current number of offline eol bridges', registry=registry)

    offline_network_eol_version_bridges.set(len(offline_eol_bridges))

    network_eol_version_bridges = Gauge('total_eol_version_bridges', 'Current number of eol bridges', ['status'], registry=registry)

    network_eol_version_bridges.labels(status='all').set(len(total_eol_bridges))

    network_eol_version_bridges.labels(status='online').set(len(online_eol_bridges))

    network_eol_version_bridges.labels(status='offline').set(len(offline_eol_bridges))

    network_countries_relays = Gauge("total_network_relays_country", "Current number of total relays per country", ['status', 'country'], registry=registry)

    for country in total_countries_relays.keys():

        if country is not None and country.isalpha():

            gauge = "total_network_{}_relays".format(country)

            total_network_countries_relays = Gauge(gauge, "Current number of relays in country {}".format(country), registry=registry)

            total_network_countries_relays.set(total_countries_relays[country])

            network_countries_relays.labels(status='all', country=country).set(total_countries_relays[country])

    for country in online_countries_relays.keys():

        if country is not None and country.isalpha():

            gauge = "online_network_{}_relays".format(country)

            online_network_countries_relays = Gauge(gauge, "Current number of online relays in country {}".format(country), registry=registry)

            online_network_countries_relays.set(online_countries_relays[country])

            network_countries_relays.labels(status='online', country=country).set(online_countries_relays[country])

    for country in offline_countries_relays.keys():

        if country is not None and country.isalpha():

            gauge = "offline_network_{}_relays".format(country)

            offline_network_countries_relays = Gauge(gauge, "Current number of offline relays in country {}".format(country), registry=registry)

            offline_network_countries_relays.set(offline_countries_relays[country])

            network_countries_relays.labels(status='offline', country=country).set(offline_countries_relays[country])

    network_flags_relays = Gauge("total_network_relays_flag", "Current number of relays per flag", ['status', 'flag'], registry=registry)

    for flag in total_flags_relays.keys():

        if flag is not None and flag.isalpha():

            gauge = "total_network_{}_relays".format(flag)

            total_network_flags_relays = Gauge(gauge, "Current number of relays in flag {}".format(flag), registry=registry)

            total_network_flags_relays.set(total_flags_relays[flag])

            network_flags_relays.labels(status='all', flag=flag).set(total_flags_relays[flag])

    for flag in online_flags_relays.keys():

        if flag is not None and flag.isalpha():

            gauge = "online_network_{}_relays".format(flag)

            online_network_flags_relays = Gauge(gauge, "Current number of online relays in flag {}".format(flag), registry=registry)

            online_network_flags_relays.set(online_flags_relays[flag])

            network_flags_relays.labels(status='online', flag=flag).set(online_flags_relays[flag])

    for flag in offline_flags_relays.keys():

        if flag is not None and flag.isalpha():

            gauge = "offline_network_{}_relays".format(flag)

            offline_network_flags_relays = Gauge(gauge, "Current number of offline relays in flag {}".format(flag), registry=registry)

            offline_network_flags_relays.set(offline_flags_relays[flag])

            network_flags_relays.labels(status='offline', flag=flag).set(offline_flags_relays[flag])

    network_flags_bridges = Gauge("total_network_bridges_flag", "Current number of bridges per flag", ['status', 'flag'], registry=registry)

    for flag in total_flags_bridges.keys():

        if flag is not None and flag.isalpha():

            gauge = "total_network_{}_bridges".format(flag)

            total_network_flags_bridges = Gauge(gauge, "Current number of bridges in flag {}".format(flag), registry=registry)

            total_network_flags_bridges.set(total_flags_bridges[flag])

            network_flags_bridges.labels(status='all', flag=flag).set(total_flags_bridges[flag])

    for flag in online_flags_bridges.keys():

        if flag is not None and flag.isalpha():

            gauge = "online_network_{}_bridges".format(flag)

            online_network_flags_bridges = Gauge(gauge, "Current number of online bridges in flag {}".format(flag), registry=registry)

            online_network_flags_bridges.set(online_flags_bridges[flag])

            network_flags_bridges.labels(status='online', flag=flag).set(online_flags_bridges[flag])

    for flag in offline_flags_bridges.keys():

        if flag is not None and flag.isalpha():

            gauge = "offline_network_{}_bridges".format(flag)

            offline_network_flags_bridges = Gauge(gauge, "Current number of offline bridges in flag {}".format(flag), registry=registry)

            offline_network_flags_bridges.set(offline_flags_bridges[flag])

            network_flags_bridges.labels(status='offline', flag=flag).set(offline_flags_bridges[flag])

    network_tor_versions_relays = Gauge("total_network_tor_version_relays", "Current number of total relays per tor version", ['status', 'version'], registry=registry)

    for version in total_tor_versions_relays.keys():

        gauge = "total_network_tor_version_{}_relays".format(version)

        total_network_tor_versions_relays = Gauge(gauge, "Current number of relays per tor version {}".format(version), registry=registry)

        total_network_tor_versions_relays.set(total_tor_versions_relays[version])

        network_tor_versions_relays.labels(status='all', version=version).set(total_tor_versions_relays[version])

    for version in online_tor_versions_relays.keys():

        gauge = "online_network_tor_version_{}_relays".format(version)

        online_network_tor_versions_relays = Gauge(gauge, "Current number of online relays per tor version {}".format(version), registry=registry)

        online_network_tor_versions_relays.set(online_tor_versions_relays[version])

        network_tor_versions_relays.labels(status='online', version=version).set(online_tor_versions_relays[version])

    for version in offline_tor_versions_relays.keys():

        gauge = "offline_network_tor_version_{}_relays".format(version)

        offline_relays_network_tor_versions = Gauge(gauge, "Current number of offline relays per tor version {}".format(version), registry=registry)

        offline_relays_network_tor_versions.set(offline_tor_versions_relays[version])

        network_tor_versions_relays.labels(status='offline', version=version).set(offline_tor_versions_relays[version])

    network_tor_versions_bridges = Gauge("total_network_tor_version_bridges", "Current number of total bridges per tor version", ['status', 'version'], registry=registry)

    for version in total_tor_versions_bridges.keys():

        gauge = "total_network_tor_version_{}_bridges".format(version)

        total_network_tor_versions_bridges = Gauge(gauge, "Current number of bridges per tor version {}".format(version), registry=registry)

        total_network_tor_versions_bridges.set(total_tor_versions_bridges[version])

        network_tor_versions_bridges.labels(status='all', version=version).set(total_tor_versions_bridges[version])

    for version in online_tor_versions_bridges.keys():

        gauge = "online_network_tor_version_{}_bridges".format(version)

        online_network_tor_versions_bridges = Gauge(gauge, "Current number of online bridges per tor version {}".format(version), registry=registry)

        online_network_tor_versions_bridges.set(online_tor_versions_bridges[version])

        network_tor_versions_bridges.labels(status='online', version=version).set(online_tor_versions_bridges[version])

    for version in offline_tor_versions_bridges.keys():

        gauge = "offline_network_tor_version_{}_bridges".format(version)

        offline_network_tor_versions_bridges = Gauge(gauge, "Current number of offline bridges per tor version {}".format(version), registry=registry)

        offline_network_tor_versions_bridges.set(offline_tor_versions_bridges[version])

        network_tor_versions_bridges.labels(status='offline', version=version).set(offline_tor_versions_bridges[version])

    network_tor_platforms_relays = Gauge("total_network_tor_platform_relays", "Current number of total relays per tor platform", ['status', 'platform'], registry=registry)

    for platform in total_tor_platforms_relays.keys():

        gauge = "total_network_tor_platform_{}_relays".format(platform)

        total_network_tor_platforms_relays = Gauge(gauge, "Current number of relays per tor platform {}".format(platform), registry=registry)

        total_network_tor_platforms_relays.set(total_tor_platforms_relays[platform])

        network_tor_platforms_relays.labels(status='all', platform=platform).set(total_tor_platforms_relays[platform])

    for platform in online_tor_platforms_relays.keys():

        gauge = "online_network_tor_platform_{}_relays".format(platform)

        online_network_tor_platforms_relays = Gauge(gauge, "Current number of online relays per tor platform {}".format(platform), registry=registry)

        online_network_tor_platforms_relays.set(online_tor_platforms_relays[platform])

        network_tor_platforms_relays.labels(status='online', platform=platform).set(online_tor_platforms_relays[platform])

    for platform in offline_tor_platforms_relays.keys():

        gauge = "offline_network_tor_platform_{}_relays".format(platform)

        offline_network_tor_platforms_relays = Gauge(gauge, "Current number of offline relays per tor platform {}".format(platform), registry=registry)

        offline_network_tor_platforms_relays.set(offline_tor_platforms_relays[platform])

        network_tor_platforms_relays.labels(status='offline', platform=platform).set(offline_tor_platforms_relays[platform])

    network_tor_platforms_bridges = Gauge("total_network_tor_platform_bridges", "Current number of total bridges per tor platform", ['status', 'platform'], registry=registry)

    for platform in total_tor_platforms_bridges.keys():

        gauge = "total_network_tor_platform_{}_bridges".format(platform)

        total_network_tor_platforms_bridges = Gauge(gauge, "Current number of bridges per tor version {}".format(platform), registry=registry)

        total_network_tor_platforms_bridges.set(total_tor_platforms_bridges[platform])

        network_tor_platforms_bridges.labels(status='all', platform=platform).set(total_tor_platforms_bridges[platform])

    for platform in online_tor_platforms_bridges.keys():

        gauge = "online_network_tor_platform_{}_bridges".format(platform)

        online_network_tor_platforms_bridges = Gauge(gauge, "Current number of online bridges per tor version {}".format(platform), registry=registry)

        online_network_tor_platforms_bridges.set(online_tor_platforms_bridges[platform])

        network_tor_platforms_bridges.labels(status='online', platform=platform).set(online_tor_platforms_bridges[platform])

    for platform in offline_tor_platforms_bridges.keys():

        gauge = "offline_network_tor_platform_{}_bridges".format(platform)

        offline_network_tor_platforms_bridges = Gauge(gauge, "Current number of offline bridges per tor version {}".format(platform), registry=registry)

        offline_network_tor_platforms_bridges.set(offline_tor_platforms_bridges[platform])

        network_tor_platforms_bridges.labels(status='offline', platform=platform).set(offline_tor_platforms_bridges[platform])

    network_tor_as_relays = Gauge("total_network_tor_as_relays", "Current number of relays per AS (Autonomous System)", ['status', 'autonomous_system'], registry=registry)

    for autonomous_system in total_as_relays.keys():

        gauge = "total_network_tor_as_{}_relays".format(autonomous_system)

        total_network_tor_as_relays = Gauge(gauge, "Current number of relays per AS (Autonomous System) {}".format(autonomous_system), registry=registry)

        total_network_tor_as_relays.set(total_as_relays[autonomous_system])

        network_tor_as_relays.labels(status='all', autonomous_system=autonomous_system).set(total_as_relays[autonomous_system])

    for autonomous_system in online_as_relays.keys():

        gauge = "online_network_tor_as_{}_relays".format(autonomous_system)

        online_network_tor_as_relays = Gauge(gauge, "Current number of online relays per AS (Autonomous System) {}".format(autonomous_system), registry=registry)

        online_network_tor_as_relays.set(online_as_relays[autonomous_system])

        network_tor_as_relays.labels(status='online', autonomous_system=autonomous_system).set(online_as_relays[autonomous_system])

    for autonomous_system in offline_as_relays.keys():

        gauge = "offline_network_tor_as_{}_relays".format(autonomous_system)

        offline_network_tor_as_relays = Gauge(gauge, "Current number of offline relays per AS (Autonomous System) {}".format(autonomous_system), registry=registry)

        offline_network_tor_as_relays.set(offline_as_relays[autonomous_system])

        network_tor_as_relays.labels(status='offline', autonomous_system=autonomous_system).set(offline_as_relays[autonomous_system])

    write_to_textfile('/srv/onionoo.torproject.org/onionoo/network/metrics', registry)

    # /srv/onionoo.torproject.org/onionoo/network/

    write_to_textfile('metrics', registry)