commit 999365adc5d4731af3b968598f292cefebe0301b · ptr.pet/nsid-tracker

+12

server/src/api.rs

···

       51
       51
        
               .route("/events", get(events))

     

       52
       52
        
               .route("/stream_events", get(stream_events))

     

       53
       53
        
               .route("/hits", get(hits))

     

       54
       54
       +
               .route("/since", get(since))

     

       54
       55
        
               .route_layer(CompressionLayer::new().br(true).deflate(true).gzip(true).zstd(true))

     

       55
       56
        
               .route_layer(PropagateRequestIdLayer::x_request_id())

     

       56
       57
        
               .route_layer(

     
···

       219
       220
        
               .instrument(span)

     

       220
       221
        
           })

     

       221
       222
        
       }

     

       223
       223
       +
       

     

       224
       224
       +
       #[derive(Debug, Serialize)]

     

       225
       225
       +
       struct Since {

     

       226
       226
       +
           since: u64,

     

       227
       227
       +
       }

     

       228
       228
       +
       

     

       229
       229
       +
       async fn since(db: State<Arc<Db>>) -> AppResult<Json<Since>> {

     

       230
       230
       +
           Ok(Json(Since {

     

       231
       231
       +
               since: db.tracking_since()?,

     

       232
       232
       +
           }))

     

       233
       233
       +
       }

+17

server/src/db.rs

···

       205
       205
        
                   },

     

       206
       206
        
               )))

     

       207
       207
        
           }

     

       208
       208
       +
       

     

       209
       209
       +
           pub fn tracking_since(&self) -> AppResult<u64> {

     

       210
       210
       +
               let _guard = self.hits.guard();

     

       211
       211
       +
               // HACK: we should actually store when we started tracking but im lazy

     

       212
       212
       +
               // should be accurate enough

     

       213
       213
       +
               let Some(tree) = self.hits.get("app.bsky.feed.like", &_guard) else {

     

       214
       214
       +
                   return Ok(0);

     

       215
       215
       +
               };

     

       216
       216
       +
       

     

       217
       217
       +
               let Some((timestamp_raw, _)) = tree.first_key_value()? else {

     

       218
       218
       +
                   return Ok(0);

     

       219
       219
       +
               };

     

       220
       220
       +
       

     

       221
       221
       +
               Ok(u64::from_be_bytes(

     

       222
       222
       +
                   timestamp_raw.as_ref().try_into().unwrap(),

     

       223
       223
       +
               ))

     

       224
       224
       +
           }

     

       208
       225
        
       }

     

       209
       226
        
       

     

       210
       227
        
       type TimestampRepr = [u8; 8];