store/postgres: Log messages about lock acquisition on subgraph logger

Author: lutter

core/src/subgraph/registrar.rs

@@ -682,7 +682,7 @@ fn create_subgraph_version(
     if deployment_exists {
         store.apply_entity_operations(ops, None)?
     } else {
-        store.create_subgraph_deployment(&manifest.id, ops)?;
+        store.create_subgraph_deployment(logger, &manifest.id, ops)?;
     }
 
     debug!(

core/tests/interfaces.rs

@@ -24,9 +24,13 @@ fn insert_and_query(
         data_sources: vec![],
     };
 
+    let logger = Logger::root(slog::Discard, o!());
+
     let ops = SubgraphDeploymentEntity::new(&manifest, false, false, Default::default(), 1)
         .create_operations_replace(&subgraph_id);
-    STORE.create_subgraph_deployment(&subgraph_id, ops).unwrap();
+    STORE
+        .create_subgraph_deployment(&logger, &subgraph_id, ops)
+        .unwrap();
 
     let insert_ops = entities
         .into_iter()
@@ -41,7 +45,6 @@ fn insert_and_query(
 
     STORE.apply_entity_operations(insert_ops.collect(), None)?;
 
-    let logger = Logger::root(slog::Discard, o!());
     let resolver = StoreResolver::new(&logger, STORE.clone());
 
     let options = QueryExecutionOptions {

graph/src/components/store.rs

@@ -1008,6 +1008,7 @@ pub trait Store: Send + Sync + 'static {
     /// version
     fn create_subgraph_deployment(
         &self,
+        subgraph_logger: &Logger,
         subgraph_id: &SubgraphDeploymentId,
         ops: Vec<EntityOperation>,
     ) -> Result<(), StoreError>;

graphql/tests/query.rs

@@ -13,7 +13,8 @@ lazy_static! {
     static ref TEST_SUBGRAPH_ID: SubgraphDeploymentId = {
         // Also populate the store when the ID is first accessed.
         let id = SubgraphDeploymentId::new("graphqlTestsQuery").unwrap();
-        STORE.create_subgraph_deployment(&id, vec![]).unwrap();
+        let logger = Logger::root(slog::Discard, o!());
+        STORE.create_subgraph_deployment(&logger, &id, vec![]).unwrap();
         insert_test_entities(&**STORE, id.clone());
         id
     };

mock/src/store.rs

@@ -331,6 +331,7 @@ impl Store for MockStore {
 
     fn create_subgraph_deployment(
         &self,
+        _logger: &Logger,
         _subgraph_id: &SubgraphDeploymentId,
         ops: Vec<EntityOperation>,
     ) -> Result<(), StoreError> {
@@ -492,6 +493,7 @@ impl Store for FakeStore {
 
     fn create_subgraph_deployment(
         &self,
+        _logger: &Logger,
         _subgraph_id: &SubgraphDeploymentId,
         _ops: Vec<EntityOperation>,
     ) -> Result<(), StoreError> {

store/postgres/src/store.rs

@@ -1023,6 +1023,7 @@ impl StoreTrait for Store {
 
     fn create_subgraph_deployment(
         &self,
+        subgraph_logger: &Logger,
         subgraph_id: &SubgraphDeploymentId,
         ops: Vec<EntityOperation>,
     ) -> Result<(), StoreError> {
@@ -1075,9 +1076,8 @@ impl StoreTrait for Store {
                 // it was because we timed out on the lock and try again.
                 if start.elapsed() >= Duration::from_secs(LOCK_TIMEOUT) {
                     debug!(
-                        self.logger,
-                        "could not acquire lock for creation of subgraph {}, trying again in {}s",
-                        &subgraph_id,
+                        subgraph_logger,
+                        "Could not acquire lock for subgraph creation, trying again in {}s",
                         delay.as_secs()
                     );
                     std::thread::sleep(delay);

store/postgres/tests/store.rs

@@ -117,7 +117,7 @@ fn insert_test_data(store: Arc<DieselStore>) {
     let ops = SubgraphDeploymentEntity::new(&manifest, false, false, *TEST_BLOCK_0_PTR, 1)
         .create_operations(&*TEST_SUBGRAPH_ID);
     store
-        .create_subgraph_deployment(&TEST_SUBGRAPH_ID, ops)
+        .create_subgraph_deployment(&*LOGGER, &TEST_SUBGRAPH_ID, ops)
         .unwrap();
 
     let test_entity_1 = create_test_entity(
@@ -1868,7 +1868,9 @@ fn entity_changes_are_fired_and_forwarded_to_subscriptions() {
         // Create SubgraphDeploymentEntity
         let ops = SubgraphDeploymentEntity::new(&manifest, false, false, *TEST_BLOCK_0_PTR, 1)
             .create_operations(&subgraph_id);
-        store.create_subgraph_deployment(&subgraph_id, ops).unwrap();
+        store
+            .create_subgraph_deployment(&*LOGGER, &subgraph_id, ops)
+            .unwrap();
 
         // Create store subscriptions
         let meta_subscription =
@@ -2186,7 +2188,7 @@ fn create_subgraph_deployment_tolerates_locks() {
         barrier.wait();
         let start = std::time::Instant::now();
         store
-            .create_subgraph_deployment(&subgraph_id, vec![])
+            .create_subgraph_deployment(&*LOGGER, &subgraph_id, vec![])
             .expect("Subgraph creation failed");
         assert!(start.elapsed() >= Duration::from_secs(BLOCK_TIME));
         Ok(())