zed-industries/zed
1
1
Fork 0
mirror of https://github.com/zed-industries/zed.git synced 2024-11-07 20:39:04 +03:00
Code Issues Packages Projects Releases Wiki Activity

nightly url setting (#7037)

Browse Source 
Release Notes:

- Added the ability to set settings per-release stage
- Added a `"server_url"` setting
This commit is contained in:
Conrad Irwin 2024-01-30 11:35:07 -07:00 committed by GitHub
parent c07355265f
commit dfbcaf36fc
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
12 changed files with 217 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.lock generated
View File

@ -9025,6 +9025,7 @@ dependencies = [
"isahc",
"lazy_static",
"log",
"parking_lot 0.11.2",
"rand 0.8.5",
"rust-embed",
"serde",

23
assets/settings/default.json
View File

@ -503,5 +503,28 @@
// }
// }
// }
},
// The server to connect to. If the environment variable
// ZED_SERVER_URL is set, it will override this setting.
"server_url": "https://zed.dev",
// Settings overrides to use when using Zed Preview.
// Mostly useful for developers who are managing multiple instances of Zed.
"preview": {
// "theme": "Andromeda"
},
// Settings overrides to use when using Zed Nightly.
// Mostly useful for developers who are managing multiple instances of Zed.
"nightly": {
// "theme": "Andromeda"
},
// Settings overrides to use when using Zed Stable.
// Mostly useful for developers who are managing multiple instances of Zed.
"stable": {
// "theme": "Andromeda"
},
// Settings overrides to use when using Zed Stable.
// Mostly useful for developers who are managing multiple instances of Zed.
"dev": {
// "theme": "Andromeda"
}
}

38
crates/auto_update/src/auto_update.rs
View File

@ -25,8 +25,11 @@ use std::{
time::Duration,
};
use update_notification::UpdateNotification;
use util::channel::{AppCommitSha, ReleaseChannel};
use util::http::HttpClient;
use util::{
channel::{AppCommitSha, ReleaseChannel},
http::ZedHttpClient,
};
use workspace::Workspace;
const SHOULD_SHOW_UPDATE_NOTIFICATION_KEY: &str = "auto-updater-should-show-updated-notification";
@ -54,9 +57,8 @@ pub enum AutoUpdateStatus {
pub struct AutoUpdater {
status: AutoUpdateStatus,
current_version: SemanticVersion,
http_client: Arc<dyn HttpClient>,
http_client: Arc<ZedHttpClient>,
pending_poll: Option<Task<Option<()>>>,
server_url: String,
}
#[derive(Deserialize)]
@ -92,7 +94,7 @@ impl Settings for AutoUpdateSetting {
}
}
pub fn init(http_client: Arc<dyn HttpClient>, server_url: String, cx: &mut AppContext) {
pub fn init(http_client: Arc<ZedHttpClient>, cx: &mut AppContext) {
AutoUpdateSetting::register(cx);
cx.observe_new_views(|workspace: &mut Workspace, _cx| {
@ -106,7 +108,7 @@ pub fn init(http_client: Arc<dyn HttpClient>, server_url: String, cx: &mut AppCo
if let Some(version) = ZED_APP_VERSION.or_else(|| cx.app_metadata().app_version) {
let auto_updater = cx.new_model(|cx| {
let updater = AutoUpdater::new(version, http_client, server_url);
let updater = AutoUpdater::new(version, http_client);
let mut update_subscription = AutoUpdateSetting::get_global(cx)
.0
@ -151,10 +153,11 @@ pub fn view_release_notes(_: &ViewReleaseNotes, cx: &mut AppContext) -> Option<(
ReleaseChannel::Stable | ReleaseChannel::Preview
) {
let auto_updater = auto_updater.read(cx);
let server_url = &auto_updater.server_url;
let release_channel = release_channel.dev_name();
let current_version = auto_updater.current_version;
let url = format!("{server_url}/releases/{release_channel}/{current_version}");
let url = &auto_updater
.http_client
.zed_url(&format!("/releases/{release_channel}/{current_version}"));
cx.open_url(&url);
}
@ -191,16 +194,11 @@ impl AutoUpdater {
cx.default_global::<Option<Model<Self>>>().clone()
}
fn new(
current_version: SemanticVersion,
http_client: Arc<dyn HttpClient>,
server_url: String,
) -> Self {
fn new(current_version: SemanticVersion, http_client: Arc<ZedHttpClient>) -> Self {
Self {
status: AutoUpdateStatus::Idle,
current_version,
http_client,
server_url,
pending_poll: None,
}
}
@ -246,18 +244,14 @@ impl AutoUpdater {
}
async fn update(this: Model<Self>, mut cx: AsyncAppContext) -> Result<()> {
let (client, server_url, current_version) = this.read_with(&cx, |this, _| {
(
this.http_client.clone(),
this.server_url.clone(),
this.current_version,
)
let (client, current_version) = this.read_with(&cx, |this, _| {
(this.http_client.clone(), this.current_version)
})?;
let mut url_string = format!(
"{server_url}/api/releases/latest?asset=Zed.dmg&os={}&arch={}",
let mut url_string = client.zed_url(&format!(
"/api/releases/latest?asset=Zed.dmg&os={}&arch={}",
OS, ARCH
);
));
cx.update(|cx| {
if let Some(param) = cx
.try_global::<ReleaseChannel>()

1
crates/channel/src/channel_store_tests.rs
View File

@ -329,6 +329,7 @@ async fn test_channel_messages(cx: &mut TestAppContext) {
fn init_test(cx: &mut AppContext) -> Model<ChannelStore> {
let settings_store = SettingsStore::test(cx);
cx.set_global(settings_store);
client::init_settings(cx);
let http = FakeHttpClient::with_404_response();
let client = Client::new(http.clone(), cx);

80
crates/client/src/client.rs
View File

@ -26,7 +26,7 @@ use rpc::proto::{AnyTypedEnvelope, EntityMessage, EnvelopedMessage, PeerId, Requ
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use serde_json;
use settings::Settings;
use settings::{Settings, SettingsStore};
use std::{
any::TypeId,
collections::HashMap,
@ -41,8 +41,8 @@ use std::{
use telemetry::Telemetry;
use thiserror::Error;
use url::Url;
use util::channel::ReleaseChannel;
use util::http::HttpClient;
use util::{channel::ReleaseChannel, http::ZedHttpClient};
use util::{ResultExt, TryFutureExt};
pub use rpc::*;
@ -50,9 +50,8 @@ pub use telemetry::Event;
pub use user::*;
lazy_static! {
pub static ref ZED_SERVER_URL: String =
std::env::var("ZED_SERVER_URL").unwrap_or_else(|_| "https://zed.dev".to_string());
pub static ref ZED_RPC_URL: Option<String> = std::env::var("ZED_RPC_URL").ok();
static ref ZED_SERVER_URL: Option<String> = std::env::var("ZED_SERVER_URL").ok();
static ref ZED_RPC_URL: Option<String> = std::env::var("ZED_RPC_URL").ok();
pub static ref IMPERSONATE_LOGIN: Option<String> = std::env::var("ZED_IMPERSONATE")
.ok()
.and_then(|s| if s.is_empty() { None } else { Some(s) });
@ -73,13 +72,45 @@ pub const CONNECTION_TIMEOUT: Duration = Duration::from_secs(5);
actions!(client, [SignIn, SignOut, Reconnect]);
#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
pub struct ClientSettingsContent {
server_url: Option<String>,
}
#[derive(Deserialize)]
pub struct ClientSettings {
pub server_url: String,
}
impl Settings for ClientSettings {
const KEY: Option<&'static str> = None;
type FileContent = ClientSettingsContent;
fn load(
default_value: &Self::FileContent,
user_values: &[&Self::FileContent],
_: &mut AppContext,
) -> Result<Self>
where
Self: Sized,
{
let mut result = Self::load_via_json_merge(default_value, user_values)?;
if let Some(server_url) = &*ZED_SERVER_URL {
result.server_url = server_url.clone()
}
Ok(result)
}
}
pub fn init_settings(cx: &mut AppContext) {
TelemetrySettings::register(cx);
cx.update_global(|store: &mut SettingsStore, cx| {
store.register_setting::<ClientSettings>(cx);
});
}
pub fn init(client: &Arc<Client>, cx: &mut AppContext) {
init_settings(cx);
let client = Arc::downgrade(client);
cx.on_action({
let client = client.clone();
@ -121,7 +152,7 @@ pub fn init(client: &Arc<Client>, cx: &mut AppContext) {
pub struct Client {
id: AtomicU64,
peer: Arc<Peer>,
http: Arc<dyn HttpClient>,
http: Arc<ZedHttpClient>,
telemetry: Arc<Telemetry>,
state: RwLock<ClientState>,
@ -390,8 +421,8 @@ impl settings::Settings for TelemetrySettings {
}
impl Client {
pub fn new(http: Arc<dyn HttpClient>, cx: &mut AppContext) -> Arc<Self> {
Arc::new(Self {
pub fn new(http: Arc<ZedHttpClient>, cx: &mut AppContext) -> Arc<Self> {
let client = Arc::new(Self {
id: AtomicU64::new(0),
peer: Peer::new(0),
telemetry: Telemetry::new(http.clone(), cx),
@ -402,14 +433,16 @@ impl Client {
authenticate: Default::default(),
#[cfg(any(test, feature = "test-support"))]
establish_connection: Default::default(),
})
});
client
}
pub fn id(&self) -> u64 {
self.id.load(std::sync::atomic::Ordering::SeqCst)
}
pub fn http_client(&self) -> Arc<dyn HttpClient> {
pub fn http_client(&self) -> Arc<ZedHttpClient> {
self.http.clone()
}
@ -925,14 +958,14 @@ impl Client {
}
async fn get_rpc_url(
http: Arc<dyn HttpClient>,
http: Arc<ZedHttpClient>,
release_channel: Option<ReleaseChannel>,
) -> Result<Url> {
if let Some(url) = &*ZED_RPC_URL {
return Url::parse(url).context("invalid rpc url");
}
let mut url = format!("{}/rpc", *ZED_SERVER_URL);
let mut url = http.zed_url("/rpc");
if let Some(preview_param) =
release_channel.and_then(|channel| channel.release_query_param())
{
@ -1053,10 +1086,10 @@ impl Client {
// Open the Zed sign-in page in the user's browser, with query parameters that indicate
// that the user is signing in from a Zed app running on the same device.
let mut url = format!(
"{}/native_app_signin?native_app_port={}&native_app_public_key={}",
*ZED_SERVER_URL, port, public_key_string
);
let mut url = http.zed_url(&format!(
"/native_app_signin?native_app_port={}&native_app_public_key={}",
port, public_key_string
));
if let Some(impersonate_login) = IMPERSONATE_LOGIN.as_ref() {
log::info!("impersonating user @{}", impersonate_login);
@ -1088,7 +1121,7 @@ impl Client {
}
let post_auth_url =
format!("{}/native_app_signin_succeeded", *ZED_SERVER_URL);
http.zed_url("/native_app_signin_succeeded");
req.respond(
tiny_http::Response::empty(302).with_header(
tiny_http::Header::from_bytes(
@ -1130,7 +1163,7 @@ impl Client {
}
async fn authenticate_as_admin(
http: Arc<dyn HttpClient>,
http: Arc<ZedHttpClient>,
login: String,
mut api_token: String,
) -> Result<Credentials> {
@ -1351,7 +1384,7 @@ async fn read_credentials_from_keychain(cx: &AsyncAppContext) -> Option<Credenti
}
let (user_id, access_token) = cx
.update(|cx| cx.read_credentials(&ZED_SERVER_URL))
.update(|cx| cx.read_credentials(&ClientSettings::get_global(cx).server_url))
.log_err()?
.await
.log_err()??;
@ -1368,7 +1401,7 @@ async fn write_credentials_to_keychain(
) -> Result<()> {
cx.update(move |cx| {
cx.write_credentials(
&ZED_SERVER_URL,
&ClientSettings::get_global(cx).server_url,
&credentials.user_id.to_string(),
credentials.access_token.as_bytes(),
)
@ -1377,7 +1410,7 @@ async fn write_credentials_to_keychain(
}
async fn delete_credentials_from_keychain(cx: &AsyncAppContext) -> Result<()> {
cx.update(move |cx| cx.delete_credentials(&ZED_SERVER_URL))?
cx.update(move |cx| cx.delete_credentials(&ClientSettings::get_global(cx).server_url))?
.await
}
@ -1684,6 +1717,7 @@ mod tests {
cx.update(|cx| {
let settings_store = SettingsStore::test(cx);
cx.set_global(settings_store);
init_settings(cx);
});
}
}

17
crates/client/src/telemetry.rs
View File

@ -1,10 +1,9 @@
mod event_coalescer;
use crate::{TelemetrySettings, ZED_SERVER_URL};
use crate::TelemetrySettings;
use chrono::{DateTime, Utc};
use futures::Future;
use gpui::{AppContext, AppMetadata, BackgroundExecutor, Task};
use lazy_static::lazy_static;
use parking_lot::Mutex;
use serde::Serialize;
use settings::{Settings, SettingsStore};
@ -13,7 +12,7 @@ use sysinfo::{
CpuRefreshKind, Pid, PidExt, ProcessExt, ProcessRefreshKind, RefreshKind, System, SystemExt,
};
use tempfile::NamedTempFile;
use util::http::HttpClient;
use util::http::{HttpClient, ZedHttpClient};
#[cfg(not(debug_assertions))]
use util::ResultExt;
use util::{channel::ReleaseChannel, TryFutureExt};
@ -21,7 +20,7 @@ use util::{channel::ReleaseChannel, TryFutureExt};
use self::event_coalescer::EventCoalescer;
pub struct Telemetry {
http_client: Arc<dyn HttpClient>,
http_client: Arc<ZedHttpClient>,
executor: BackgroundExecutor,
state: Arc<Mutex<TelemetryState>>,
}
@ -43,12 +42,6 @@ struct TelemetryState {
max_queue_size: usize,
}
const EVENTS_URL_PATH: &'static str = "/api/events";
lazy_static! {
static ref EVENTS_URL: String = format!("{}{}", *ZED_SERVER_URL, EVENTS_URL_PATH);
}
#[derive(Serialize, Debug)]
struct EventRequestBody {
installation_id: Option<Arc<str>>,
@ -149,7 +142,7 @@ const FLUSH_INTERVAL: Duration = Duration::from_secs(1);
const FLUSH_INTERVAL: Duration = Duration::from_secs(60 * 5);
impl Telemetry {
pub fn new(client: Arc<dyn HttpClient>, cx: &mut AppContext) -> Arc<Self> {
pub fn new(client: Arc<ZedHttpClient>, cx: &mut AppContext) -> Arc<Self> {
let release_channel = cx
.try_global::<ReleaseChannel>()
.map(|release_channel| release_channel.display_name());
@ -548,7 +541,7 @@ impl Telemetry {
}
this.http_client
.post_json(EVENTS_URL.as_str(), json_bytes.into())
.post_json(&this.http_client.zed_url("/api/events"), json_bytes.into())
.await?;
anyhow::Ok(())
}

1
crates/collab/src/tests/test_server.rs
View File

@ -153,6 +153,7 @@ impl TestServer {
}
let settings = SettingsStore::test(cx);
cx.set_global(settings);
client::init_settings(cx);
});
let http = FakeHttpClient::with_404_response();

6
crates/feedback/src/feedback_modal.rs
View File

@ -2,7 +2,7 @@ use std::{ops::RangeInclusive, sync::Arc, time::Duration};
use anyhow::{anyhow, bail};
use bitflags::bitflags;
use client::{Client, ZED_SERVER_URL};
use client::Client;
use db::kvp::KEY_VALUE_STORE;
use editor::{Editor, EditorEvent};
use futures::AsyncReadExt;
@ -16,7 +16,7 @@ use project::Project;
use regex::Regex;
use serde_derive::Serialize;
use ui::{prelude::*, Button, ButtonStyle, IconPosition, Tooltip};
use util::ResultExt;
use util::{http::HttpClient, ResultExt};
use workspace::{ModalView, Toast, Workspace};
use crate::{system_specs::SystemSpecs, GiveFeedback, OpenZedRepo};
@ -293,12 +293,12 @@ impl FeedbackModal {
}
}
let feedback_endpoint = format!("{}/api/feedback", *ZED_SERVER_URL);
let telemetry = zed_client.telemetry();
let metrics_id = telemetry.metrics_id();
let installation_id = telemetry.installation_id();
let is_staff = telemetry.is_staff();
let http_client = zed_client.http_client();
let feedback_endpoint = http_client.zed_url("/api/feedback");
let request = FeedbackRequestBody {
feedback_text: &feedback_text,
email,

42
crates/settings/src/settings_store.rs
View File

@ -1,6 +1,6 @@
use anyhow::{anyhow, Context, Result};
use collections::{btree_map, hash_map, BTreeMap, HashMap};
use gpui::AppContext;
use gpui::{AppContext, AsyncAppContext};
use lazy_static::lazy_static;
use schemars::{gen::SchemaGenerator, schema::RootSchema, JsonSchema};
use serde::{de::DeserializeOwned, Deserialize as _, Serialize};
@ -13,7 +13,9 @@ use std::{
str,
sync::Arc,
};
use util::{merge_non_null_json_value_into, RangeExt, ResultExt as _};
use util::{
channel::RELEASE_CHANNEL_NAME, merge_non_null_json_value_into, RangeExt, ResultExt as _,
};
/// A value that can be defined as a user setting.
///
@ -102,6 +104,14 @@ pub trait Settings: 'static + Send + Sync {
cx.global::<SettingsStore>().get(None)
}
#[track_caller]
fn try_read_global<'a, R>(cx: &'a AsyncAppContext, f: impl FnOnce(&Self) -> R) -> Option<R>
where
Self: Sized,
{
cx.try_read_global(|s: &SettingsStore, _| f(s.get(None)))
}
#[track_caller]
fn override_global<'a>(settings: Self, cx: &'a mut AppContext)
where
@ -197,6 +207,15 @@ impl SettingsStore {
user_values_stack = vec![user_settings];
}
if let Some(release_settings) = &self.raw_user_settings.get(&*RELEASE_CHANNEL_NAME) {
if let Some(release_settings) = setting_value
.deserialize_setting(&release_settings)
.log_err()
{
user_values_stack.push(release_settings);
}
}
if let Some(setting) = setting_value
.load_setting(&default_settings, &user_values_stack, cx)
.context("A default setting must be added to the `default.json` file")
@ -484,6 +503,15 @@ impl SettingsStore {
}
}
for release_stage in ["dev", "nightly", "stable", "preview"] {
let schema = combined_schema.schema.clone();
combined_schema
.schema
.object()
.properties
.insert(release_stage.to_string(), schema.into());
}
serde_json::to_value(&combined_schema).unwrap()
}
@ -509,6 +537,16 @@ impl SettingsStore {
paths_stack.push(None);
}
if let Some(release_settings) = &self.raw_user_settings.get(&*RELEASE_CHANNEL_NAME) {
if let Some(release_settings) = setting_value
.deserialize_setting(&release_settings)
.log_err()
{
user_settings_stack.push(release_settings);
paths_stack.push(None);
}
}
// If the global settings file changed, reload the global value for the field.
if changed_local_path.is_none() {
if let Some(value) = setting_value

1
crates/util/Cargo.toml
View File

@ -30,6 +30,7 @@ serde_json.workspace = true
git2 = { workspace = true, optional = true }
dirs = "3.0"
take-until = "0.2.0"
parking_lot.workspace = true
[target.'cfg(windows)'.dependencies]
tendril = "0.4.3"

50
crates/util/src/http.rs
View File

@ -6,12 +6,49 @@ pub use isahc::{
Error,
};
pub use isahc::{AsyncBody, Request, Response};
use parking_lot::Mutex;
use smol::future::FutureExt;
#[cfg(feature = "test-support")]
use std::fmt;
use std::{sync::Arc, time::Duration};
pub use url::Url;
pub struct ZedHttpClient {
pub zed_host: Mutex<String>,
client: Box<dyn HttpClient>,
}
impl ZedHttpClient {
pub fn zed_url(&self, path: &str) -> String {
format!("{}{}", self.zed_host.lock(), path)
}
}
impl HttpClient for Arc<ZedHttpClient> {
fn send(&self, req: Request<AsyncBody>) -> BoxFuture<Result<Response<AsyncBody>, Error>> {
self.client.send(req)
}
}
impl HttpClient for ZedHttpClient {
fn send(&self, req: Request<AsyncBody>) -> BoxFuture<Result<Response<AsyncBody>, Error>> {
self.client.send(req)
}
}
pub fn zed_client(zed_host: &str) -> Arc<ZedHttpClient> {
Arc::new(ZedHttpClient {
zed_host: Mutex::new(zed_host.to_string()),
client: Box::new(
isahc::HttpClient::builder()
.connect_timeout(Duration::from_secs(5))
.low_speed_timeout(100, Duration::from_secs(5))
.build()
.unwrap(),
),
})
}
pub trait HttpClient: Send + Sync {
fn send(&self, req: Request<AsyncBody>) -> BoxFuture<Result<Response<AsyncBody>, Error>>;
@ -81,17 +118,20 @@ pub struct FakeHttpClient {
#[cfg(feature = "test-support")]
impl FakeHttpClient {
pub fn create<Fut, F>(handler: F) -> Arc<dyn HttpClient>
pub fn create<Fut, F>(handler: F) -> Arc<ZedHttpClient>
where
Fut: 'static + Send + futures::Future<Output = Result<Response<AsyncBody>, Error>>,
F: 'static + Send + Sync + Fn(Request<AsyncBody>) -> Fut,
{
Arc::new(Self {
handler: Box::new(move |req| Box::pin(handler(req))),
Arc::new(ZedHttpClient {
zed_host: Mutex::new("http://test.example".into()),
client: Box::new(Self {
handler: Box::new(move |req| Box::pin(handler(req))),
}),
})
}
pub fn with_404_response() -> Arc<dyn HttpClient> {
pub fn with_404_response() -> Arc<ZedHttpClient> {
Self::create(|_| async move {
Ok(Response::builder()
.status(404)
@ -100,7 +140,7 @@ impl FakeHttpClient {
})
}
pub fn with_200_response() -> Arc<dyn HttpClient> {
pub fn with_200_response() -> Arc<ZedHttpClient> {
Self::create(|_| async move {
Ok(Response::builder()
.status(200)

33
crates/zed/src/main.rs
View File

@ -42,7 +42,7 @@ use theme::{ActiveTheme, ThemeRegistry, ThemeSettings};
use util::{
async_maybe,
channel::{parse_zed_link, AppCommitSha, ReleaseChannel, RELEASE_CHANNEL},
http::{self, HttpClient},
http::{self, HttpClient, ZedHttpClient},
paths::{self, CRASHES_DIR, CRASHES_RETIRED_DIR},
ResultExt,
};
@ -59,7 +59,6 @@ fn main() {
menu::init();
zed_actions::init();
let http = http::client();
init_paths();
init_logger();
@ -132,6 +131,9 @@ fn main() {
cx.set_global(store);
handle_settings_file_changes(user_settings_file_rx, cx);
handle_keymap_file_changes(user_keymap_file_rx, cx);
client::init_settings(cx);
let http = http::zed_client(&client::ClientSettings::get_global(cx).server_url);
let client = client::Client::new(http.clone(), cx);
let mut languages = LanguageRegistry::new(login_shell_env_loaded);
@ -201,7 +203,20 @@ fn main() {
languages.set_theme(cx.theme().clone());
cx.observe_global::<SettingsStore>({
let languages = languages.clone();
move |cx| languages.set_theme(cx.theme().clone())
let http = http.clone();
let client = client.clone();
move |cx| {
languages.set_theme(cx.theme().clone());
let new_host = &client::ClientSettings::get_global(cx).server_url;
let mut host = http.zed_host.lock();
if &*host != new_host {
*host = new_host.clone();
if client.status().borrow().is_connected() {
client.reconnect(&cx.to_async());
}
}
}
})
.detach();
@ -230,7 +245,7 @@ fn main() {
cx.set_global(Arc::downgrade(&app_state));
audio::init(Assets, cx);
auto_update::init(http.clone(), client::ZED_SERVER_URL.clone(), cx);
auto_update::init(http.clone(), cx);
workspace::init(app_state.clone(), cx);
recent_projects::init(cx);
@ -634,7 +649,7 @@ fn init_panic_hook(app: &App, installation_id: Option<String>, session_id: Strin
}));
}
fn upload_panics_and_crashes(http: Arc<dyn HttpClient>, cx: &mut AppContext) {
fn upload_panics_and_crashes(http: Arc<ZedHttpClient>, cx: &mut AppContext) {
let telemetry_settings = *client::TelemetrySettings::get_global(cx);
cx.background_executor()
.spawn(async move {
@ -650,10 +665,10 @@ fn upload_panics_and_crashes(http: Arc<dyn HttpClient>, cx: &mut AppContext) {
/// upload panics to us (via zed.dev)
async fn upload_previous_panics(
http: Arc<dyn HttpClient>,
http: Arc<ZedHttpClient>,
telemetry_settings: client::TelemetrySettings,
) -> Result<()> {
let panic_report_url = format!("{}/api/panic", &*client::ZED_SERVER_URL);
let panic_report_url = http.zed_url("/api/panic");
let mut children = smol::fs::read_dir(&*paths::LOGS_DIR).await?;
while let Some(child) = children.next().await {
let child = child?;
@ -717,7 +732,7 @@ static LAST_CRASH_UPLOADED: &'static str = "LAST_CRASH_UPLOADED";
/// upload crashes from apple's diagnostic reports to our server.
/// (only if telemetry is enabled)
async fn upload_previous_crashes(
http: Arc<dyn HttpClient>,
http: Arc<ZedHttpClient>,
telemetry_settings: client::TelemetrySettings,
) -> Result<()> {
if !telemetry_settings.diagnostics {
@ -728,7 +743,7 @@ async fn upload_previous_crashes(
.unwrap_or("zed-2024-01-17-221900.ips".to_string()); // don't upload old crash reports from before we had this.
let mut uploaded = last_uploaded.clone();
let crash_report_url = format!("{}/api/crash", &*client::ZED_SERVER_URL);
let crash_report_url = http.zed_url("/api/crash");
for dir in [&*CRASHES_DIR, &*CRASHES_RETIRED_DIR] {
let mut children = smol::fs::read_dir(&dir).await?;