Changing logging to use print on python

Signed-off-by: Alice Gibbons <alice@diagrid.io>

Author: alicejgibbons

conversation/python/http/conversation/app.py

@@ -10,16 +10,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ------------------------------------------------------------
-import logging
 import requests
 import os
 
-# Configure logging to only show the message without level/logger prefix
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(message)s'
-)
-
 base_url = os.getenv('BASE_URL', 'http://localhost') + ':' + os.getenv(
                     'DAPR_HTTP_PORT', '3500')
 
@@ -53,34 +46,33 @@
     json=input
 )
 
-logging.info('Conversation input sent: What is dapr?')
+print('Conversation input sent: What is dapr?')
 
 # Parse conversation output
 data = result.json()
 try:
     if 'outputs' in data and len(data['outputs']) > 0:
         out = data['outputs'][0]
         if out.get('model'):
-            logging.info('Model: ' + out['model'])
+            print('Model: ' + out['model'])
         if out.get('usage'):
             u = out['usage']
-            logging.info('Usage: prompt_tokens=%s completion_tokens=%s total_tokens=%s',
-                         u.get('promptTokens'), u.get('completionTokens'), u.get('totalTokens'))
+            print(f'Usage: prompt_tokens={u.get("promptTokens")} completion_tokens={u.get("completionTokens")} total_tokens={u.get("totalTokens")}')
         if 'choices' in out and len(out['choices']) > 0:
             output = out["choices"][0]["message"]["content"]
-            logging.info('Output response: ' + output)
+            print('Output response: ' + output)
         else:
-            logging.error('No choices in output')
+            print('No choices in output')
     else:
-        logging.error('No outputs found in response')
-        logging.error('Response data: ' + str(data))
+        print('No outputs found in response')
+        print('Response data: ' + str(data))
 
 except (KeyError, IndexError) as e:
-    logging.error(f'Error parsing response: {e}')
+    print(f'Error parsing response: {e}')
     if 'outputs' in data:
-        logging.info(f'Available outputs: {data["outputs"]}')
+        print(f'Available outputs: {data["outputs"]}')
     else:
-        logging.info(f'No outputs found in response')
+        print('No outputs found in response')
 
 tool_call_input = {
     'inputs': [{
@@ -140,41 +132,40 @@
     json=tool_call_input
 )
 
-logging.info('Tool calling input sent: What is the weather like in San Francisco in celsius?')
+print('Tool calling input sent: What is the weather like in San Francisco in celsius?')
 
 # Parse conversation output
 data = tool_call_result.json()
 if 'outputs' in data and len(data['outputs']) > 0:
     output = data['outputs'][0]
     if output.get('model'):
-        logging.info('Model: %s', output['model'])
+        print('Model: ' + output['model'])
     if output.get('usage'):
         u = output['usage']
-        logging.info('Usage: prompt_tokens=%s completion_tokens=%s total_tokens=%s',
-                     u.get('promptTokens'), u.get('completionTokens'), u.get('totalTokens'))
+        print(f'Usage: prompt_tokens={u.get("promptTokens")} completion_tokens={u.get("completionTokens")} total_tokens={u.get("totalTokens")}')
     if 'choices' in output and len(output['choices']) > 0:
         choice = output['choices'][0]
         if 'message' in choice:
             message = choice['message']
 
             if 'content' in message and message['content']:
-                logging.info('Output message: ' + message['content'])
+                print('Output message: ' + message['content'])
 
             if 'toolCalls' in message and message['toolCalls']:
-                logging.info('Tool calls detected:')
+                print('Tool calls detected:')
                 for tool_call in message['toolCalls']:
-                    logging.info('Tool call: ' + str(tool_call))
+                    print('Tool call: ' + str(tool_call))
 
                     if 'function' in tool_call:
                         func_call = tool_call['function']
-                        logging.info(f"Function name: {func_call.get('name', 'unknown')}")
-                        logging.info(f"Function arguments: {func_call.get('arguments', 'none')}")
+                        print(f"Function name: {func_call.get('name', 'unknown')}")
+                        print(f"Function arguments: {func_call.get('arguments', 'none')}")
             else:
-                logging.info('Tool calls not found')
+                print('Tool calls not found')
         else:
-            logging.error('No message in choice')
+            print('No message in choice')
     else:
-        logging.error('No choices in output')
+        print('No choices in output')
 else:
-    logging.error('No outputs in response')
-    logging.error('Response data: ' + str(data)) 
+    print('No outputs in response')
+    print('Response data: ' + str(data))

jobs/python/sdk/job-service/app.py

@@ -1,6 +1,5 @@
 import os
 import json
-import logging
 from datetime import timedelta
 from typing import Optional
 from fastapi import FastAPI, HTTPException, Response
@@ -16,10 +15,6 @@
     print('Warning: protobuf not available, jobs with data will be scheduled without data', flush=True)
 
 
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
 # Initialize FastAPI app
 app = FastAPI(title="Dapr Jobs Service", version="1.0.0")
 

pub_sub/python/sdk/checkout/app.py

@@ -1,9 +1,6 @@
 from dapr.clients import DaprClient
 import json
 import time
-import logging
-
-logging.basicConfig(level=logging.INFO)
 
 with DaprClient() as client:
     for i in range(1, 10):
@@ -15,5 +12,5 @@
             data=json.dumps(order),
             data_content_type='application/json',
         )
-        logging.info('Published data: ' + json.dumps(order))
+        print('Published data: ' + json.dumps(order))
         time.sleep(1)

secrets_management/python/http/order-processor/app.py

@@ -2,8 +2,6 @@
 import requests
 import os
 
-logging.basicConfig(level=logging.INFO)
-
 base_url = os.getenv('BASE_URL', 'http://localhost') + ':' + os.getenv(
                     'DAPR_HTTP_PORT', '3500')
 DAPR_SECRET_STORE = 'localsecretstore'

secrets_management/python/sdk/order-processor/app.py

@@ -1,4 +1,3 @@
-import logging
 from dapr.clients import DaprClient
 
 DAPR_SECRET_STORE = 'localsecretstore'

workflows/python/sdk/order-processor/workflow.py

@@ -1,5 +1,4 @@
 from datetime import timedelta
-import logging
 import json
 
 from dapr.ext.workflow import DaprWorkflowContext, WorkflowActivityContext, WorkflowRuntime, when_any
@@ -13,8 +12,6 @@
 
 wfr = WorkflowRuntime()
 
-logging.basicConfig(level=logging.INFO)
-
 
 @wfr.workflow(name="order_processing_workflow")
 def order_processing_workflow(ctx: DaprWorkflowContext, order_payload_str: str):
@@ -78,36 +75,28 @@ def order_processing_workflow(ctx: DaprWorkflowContext, order_payload_str: str):
 @wfr.activity(name="notify_activity")
 def notify_activity(ctx: WorkflowActivityContext, input: Notification):
     """Defines Notify Activity. This is used by the workflow to send out a notification"""
-    # Create a logger
-    logger = logging.getLogger('NotifyActivity')
-    logger.info(input.message)
+    print(input.message, flush=True)
 
 
 @wfr.activity(name="process_payment_activity")
 def process_payment_activity(ctx: WorkflowActivityContext, input: PaymentRequest):
     """Defines Process Payment Activity.This is used by the workflow to process a payment"""
-    logger = logging.getLogger('ProcessPaymentActivity')
-    logger.info('Processing payment: '+f'{input.request_id}'+' for '
-                +f'{input.quantity}' +' ' +f'{input.item_being_purchased}'+' at '+f'{input.amount}'
-                +' USD')
-    logger.info(f'Payment for request ID {input.request_id} processed successfully')
+    print(f'Processing payment: {input.request_id} for {input.quantity} {input.item_being_purchased} at {input.amount} USD', flush=True)
+    print(f'Payment for request ID {input.request_id} processed successfully', flush=True)
 
 
 @wfr.activity(name="verify_inventory_activity")
 def verify_inventory_activity(ctx: WorkflowActivityContext,
                               input: InventoryRequest) -> InventoryResult:
     """Defines Verify Inventory Activity. This is used by the workflow to verify if inventory
     is available for the order"""
-    logger = logging.getLogger('VerifyInventoryActivity')
-
-    logger.info('Verifying inventory for order '+f'{input.request_id}'+' of '
-                +f'{input.quantity}' +' ' +f'{input.item_name}')
+    print(f'Verifying inventory for order {input.request_id} of {input.quantity} {input.item_name}', flush=True)
     with DaprClient(f'{settings.DAPR_RUNTIME_HOST}:{settings.DAPR_GRPC_PORT}') as client:
         result = client.get_state(store_name, input.item_name)
     if result.data is None:
         return InventoryResult(False, None)
     res_json=json.loads(str(result.data.decode('utf-8')))
-    logger.info(f'There are {res_json["quantity"]} {res_json["name"]} available for purchase')
+    print(f'There are {res_json["quantity"]} {res_json["name"]} available for purchase', flush=True)
     inventory_item = InventoryItem(item_name=input.item_name,
                                   per_item_cost=res_json['per_item_cost'],
                                   quantity=res_json['quantity'])
@@ -124,10 +113,7 @@ def update_inventory_activity(ctx: WorkflowActivityContext,
     """Defines Update Inventory Activity. This is used by the workflow to check if inventory
     is sufficient to fulfill the order and updates inventory by reducing order quantity from
     inventory."""
-    logger = logging.getLogger('UpdateInventoryActivity')
-
-    logger.info('Checking inventory for order ' +f'{input.request_id}'+' for '
-                +f'{input.quantity}' +' ' +f'{input.item_being_purchased}')
+    print(f'Checking inventory for order {input.request_id} for {input.quantity} {input.item_being_purchased}', flush=True)
     with DaprClient(f'{settings.DAPR_RUNTIME_HOST}:{settings.DAPR_GRPC_PORT}') as client:
         result = client.get_state(store_name, input.item_being_purchased)
         res_json=json.loads(str(result.data.decode('utf-8')))
@@ -138,7 +124,7 @@ def update_inventory_activity(ctx: WorkflowActivityContext,
                              +' could not be processed. Insufficient inventory.')
         new_val = f'{{"name": "{input.item_being_purchased}", "quantity": {str(new_quantity)}, "per_item_cost": {str(per_item_cost)}}}'
         client.save_state(store_name, input.item_being_purchased, new_val)
-        logger.info(f'There are now {new_quantity} {input.item_being_purchased} left in stock')
+        print(f'There are now {new_quantity} {input.item_being_purchased} left in stock', flush=True)
 
 
 
@@ -148,7 +134,4 @@ def request_approval_activity(ctx: WorkflowActivityContext,
     """Defines Request Approval Activity. This is used by the workflow to request approval
     for payment of an order. This activity is used only if the order total cost is greater than
     a particular threshold"""
-    logger = logging.getLogger('RequestApprovalActivity')
-
-    logger.info('Requesting approval for payment of '+f'{input["total_cost"]}'+' USD for '
-                +f'{input["quantity"]}' +' ' +f'{input["item_name"]}')
+    print(f'Requesting approval for payment of {input["total_cost"]} USD for {input["quantity"]} {input["item_name"]}', flush=True)