Some error handling from vendor resources

.env.template

···
 STAR_THRESHOLD=1
 
 # Timeframe in hours to gate posts after a threshold is met (default 24)
-POST_WINDOW_HOURS=24
+POST_WINDOW_HOURS=24
+
+DATABASE_URL=./stitch_counter.sqlite
+JETSTREAM_URL="wss://jetstream1.us-east.fire.hose.cam/subscribe"

bot/src/main.rs

···
 use atrium_api::types::{Collection, Union};
 use dotenv::dotenv;
 use logic::BotApi;
+use rocketman::endpoints::JetstreamEndpoints;
 use rocketman::{
     connection::JetstreamConnection, handler, ingestion::LexiconIngestor,
     options::JetstreamOptions, types::event::Operation,
···
     // Run migrations from ./migrations
     sqlx::migrate!("./migrations").run(&pool).await?;
 
+    let jet_stream = match std::env::var("JETSTREAM_URL") {
+        Ok(url) => JetstreamEndpoints::Custom(url.into()),
+        Err(_) => JetstreamEndpoints::default(),
+    };
     // Configure Jetstream to listen to sh.tangled.feed.star
     let opts = JetstreamOptions::builder()
+        .ws_url(jet_stream)
         .wanted_collections(vec![atproto_api::sh::tangled::feed::Star::NSID.to_string()])
         .build();
 
···
 
                                     let parsed = parse_uri(&repo_subject)?;
                                     let cloned_repo_owner = parsed.did.clone();
-                                    let stars = fetch_constellation_count(&repo_subject).await?;
+                                    let stars = fetch_constellation_count(&repo_subject)
+                                        .await
+                                        .unwrap_or_else(|err| {
+                                            log::error!("Error calling constellation: {:?}", err);
+                                            0
+                                        });
                                     let repo_record = &self
                                         .sling_shot
                                         .get_record::<atproto_api::sh::tangled::repo::RecordData>(
···
                                         "https://tangled-search.bigmoves.deno.net/repo-image/{}",
                                         encoded_subject
                                     );
-                                    let bytes = reqwest::get(url).await?.bytes().await?.to_vec();
-
-                                    let blob_upload = &self
-                                        .bot
-                                        .agent
-                                        .api
-                                        .com
-                                        .atproto
-                                        .repo
-                                        .upload_blob(bytes)
-                                        .await?;
+                                    log::info!("Attempting to get the picture at: {url}");
 
-                                    // let rt = RichText::new_with_detect_facets(format!(
-                                    //     "{handle_and_repo}{description}\n⭐️ {stars} {tangled_sh_url}"
-                                    // ))
-                                    //     .await?;
                                     let post_text =
                                         format!("{handle_and_repo}{description}\n⭐️ {stars}");
 
-                                    let image = atrium_api::app::bsky::embed::images::ImageData {
-                                        alt: format!(
-                                            "An image showing the same text inside of the post. {post_text}"
-                                        ),
-                                        aspect_ratio: Some(
-                                            atrium_api::app::bsky::embed::defs::AspectRatioData {
-                                                height: NonZeroU64::try_from(400_u64)?,
-                                                width: NonZeroU64::try_from(800_u64)?,
-                                            }
-                                            .into(),
-                                        ),
-                                        //Good lord how many clones is that
-                                        image: blob_upload.clone().blob.clone(),
+                                    let response = reqwest::get(url).await?;
+
+                                    let embed = match response.status().is_success() {
+                                        true => {
+                                            let bytes = response.bytes().await?.to_vec();
+                                            let blob_upload = &self
+                                                .bot
+                                                .agent
+                                                .api
+                                                .com
+                                                .atproto
+                                                .repo
+                                                .upload_blob(bytes)
+                                                .await?;
+
+                                            let image = atrium_api::app::bsky::embed::images::ImageData {
+                                                alt: format!(
+                                                    "An image showing the same text inside of the post. {post_text}"
+                                                ),
+                                                aspect_ratio: Some(
+                                                    atrium_api::app::bsky::embed::defs::AspectRatioData {
+                                                        height: NonZeroU64::try_from(400_u64)?,
+                                                        width: NonZeroU64::try_from(800_u64)?,
+                                                    }
+                                                        .into(),
+                                                ),
+                                                //Good lord how many clones is that
+                                                image: blob_upload.clone().blob.clone(),
+                                            };
+                                            Some(atrium_api::types::Union::Refs(
+                                                RecordEmbedRefs::AppBskyEmbedImagesMain(Box::new(
+                                                    atrium_api::app::bsky::embed::images::MainData {
+                                                        images: vec![image.into()],
+                                                    }
+                                                        .into(),
+                                                )),
+                                            ))
+                                        }
+                                        false => None,
                                     };
-                                    let embed = Some(atrium_api::types::Union::Refs(
-                                        RecordEmbedRefs::AppBskyEmbedImagesMain(Box::new(
-                                            atrium_api::app::bsky::embed::images::MainData {
-                                                images: vec![image.into()],
-                                            }
-                                            .into(),
-                                        )),
-                                    ));
 
                                     let post = atrium_api::app::bsky::feed::post::RecordData {
                                         created_at: atrium_api::types::string::Datetime::now(),