To see all the pending / Running requests per each manager wise

SELECT c.user_name, request_id, phase_code, status_code, hold_flag, TO_CHAR(requested_start_date,'DD-MON-YY:HH24:MM:SS') Requested_Start_Date, user_concurrent_program_name, b.concurrent_program_id FROM applsys.fnd_concurrent_requests a, applsys.fnd_concurrent_programs_tl b, applsys.fnd_user c WHERE 1=1 AND a.status_code in ('C','F','I','Q','R') --AND a.phase_code IN ('P','R') AND a.phase_code IN ('P') AND a.concurrent_program_id = b.concurrent_program_id AND b.LANGUAGE = 'US' AND c.user_id = a.requested_by and c.user_name like '05%' and trunc(requested_start_date) = trunc(sysdate) ORDER BY user_name,user_concurrent_program_name;

How to Find Out Scheduled Concurrent Requests in Oracle Applications 11i

SELECT req.request_id , fus.user_name as owner , decode (prg.user_concurrent_program_name, 'Report Set', 'Report Set:' || req.description, prg.user_concurrent_program_name) AS name , argument_text as parameters , req.resubmit_interval , nvl2 (req.resubmit_interval, 'Periodically', nvl2 (req.release_class_id, 'On specific days', 'Once')) AS schedule_type , decode (nvl2 (req.resubmit_interval, 'Periodically', nvl2 (req.release_class_id, 'On specific days', 'Once')), 'Periodically', 'Every ' || req.resubmit_interval || ' ' || lower(req.resubmit_interval_unit_code) || ' from ' || lower(req.resubmit_interval_type_code) || ' of previous run', 'Once', 'At :' || to_char (req.requested_start_date, 'DD-MON-RR HH24:MI'), 'Every: ' || crc.class_info) as schedule , to_char(requested_start_date,'DD-MON-YYYY HH24:MI:SS') as next_submission FROM apps.fnd_concurrent_programs_tl prg , apps.fnd_concurrent_requests req , apps.fnd_user fus , apps.fnd_conc_release_classes crc WHERE 1=1 AND prg.application_id = req.program_application_id AND prg.concurrent_program_id = req.concurrent_program_id AND req.requested_by = fus.user_id --AND req.phase_code in ('P','R') AND req.phase_code in ('P') --AND req.requested_start_date > sysdate AND trunc(req.requested_start_date) = trunc(sysdate) AND prg.language = 'US' AND crc.release_class_id(+) = req.release_class_id AND crc.application_id(+) = req.release_class_app_id

--AND name like '%Requisition%' and fus.user_name like '05%' and decode (prg.user_concurrent_program_name, 'Report Set', 'Report Set:' || req.description, prg.user_concurrent_program_name) = '05 AR Autoinvoice Master Program' ORDER BY name,owner,parameters,next_submission;

---------------------------------------------------------------------select request_id from fnd_concurrent_requests where status_code in ('Q','I') and requested_start_date > SYSDATE and hold_flag = 'N';

Query to Pull up Concurrent Requests R12

SELECT r.request_id, DECODE (r.description, NULL, pt.user_concurrent_program_name, r.description || ' ( ' || pt.user_concurrent_program_name || ' ) ' ) program, r.phase_code, r.status_code, fnd_amp_private.get_phase (r.phase_code, r.status_code, r.hold_flag, p.enabled_flag, r.requested_start_date, r.request_id ) phase, fnd_amp_private.get_status (r.phase_code, r.status_code, r.hold_flag, p.enabled_flag, r.requested_start_date, r.request_id ) STATUS, u.user_name, rt.responsibility_name, AT.application_name, r.requested_start_date, r.actual_start_date, r.actual_completion_date, r.request_date, r.argument_text, r.oracle_session_id, r.completion_text, r.controlling_manager, r.requested_by, r.program_application_id, r.concurrent_program_id, r.is_sub_request, r.parent_request_id, r.queue_method_code, r.cd_id,

FROM

WHERE AND AND AND AND AND AND AND AND AND AND AND

r.hold_flag, p.enabled_flag, p.concurrent_program_name, p.user_concurrent_program_name, r.os_process_id, r.nls_language, r.nls_territory, r.nls_numeric_characters, r.description fnd_concurrent_programs_tl pt, fnd_responsibility_tl rt, fnd_application_tl AT, fnd_concurrent_programs_vl p, fnd_user u, fnd_concurrent_requests r r.program_application_id = p.application_id r.concurrent_program_id = p.concurrent_program_id pt.concurrent_program_id = p.concurrent_program_id pt.application_id = p.application_id pt.LANGUAGE = USERENV ('LANG') u.user_id = r.requested_by rt.application_id = r.responsibility_application_id rt.responsibility_id = r.responsibility_id rt.LANGUAGE = USERENV ('LANG') AT.application_id = r.program_application_id AT.LANGUAGE = USERENV ('LANG') r.request_id = :request_id;

Scheduled concurrent requests

Lot of times we need to find out the concurrent programs scheduled. Users can schedule the concurrent requests in three ways (To run once at a specified time / To run periodically / To run on specific days of the month or week). The below query will return all the concurrent requests which are scheduled using any of the above methods:
SELECT cr.request_id, DECODE (cp.user_concurrent_program_name, 'Report Set', 'Report Set:' || cr.description, cp.user_concurrent_program_name ) NAME, argument_text, cr.resubmit_interval, NVL2 (cr.resubmit_interval, 'PERIODICALLY', NVL2 (cr.release_class_id, 'ON SPECIFIC DAYS', 'ONCE') ) schedule_type, DECODE (NVL2 (cr.resubmit_interval, 'PERIODICALLY', NVL2 (cr.release_class_id, 'ON SPECIFIC DAYS', 'ONCE')

), 'PERIODICALLY', 'EVERY ' || cr.resubmit_interval || ' ' || cr.resubmit_interval_unit_code || ' FROM ' || cr.resubmit_interval_type_code || ' OF PREV RUN', 'ONCE', 'AT :' || TO_CHAR (cr.requested_start_date, 'DD-MON-RR HH24:MI'), 'EVERY: ' || fcr.class_info ) schedule, fu.user_name, requested_start_date FROM apps.fnd_concurrent_programs_tl cp, apps.fnd_concurrent_requests cr, apps.fnd_user fu, apps.fnd_conc_release_classes fcr WHERE cp.application_id = cr.program_application_id AND cp.concurrent_program_id = cr.concurrent_program_id AND cr.requested_by = fu.user_id AND cr.phase_code = 'P' AND cr.requested_start_date > SYSDATE AND cp.LANGUAGE = 'US' AND fcr.release_class_id(+) = cr.release_class_id AND fcr.application_id(+) = cr.release_class_app_id;

Note: The "SCHEDULE" column in the above query returns a string of zeros and ones for the requests which are scheduled on specific days of the month or week. Positions 1 through 31: Specific day of the month. Position 32: Last day of the month Positions 33 through 39: Sunday through Saturday

Checking the duplicated schedules of the same program with the same arguments
The below query can be used to check the duplicated schedule of the same program with the same arguments. This can be used to alert the users to cancel these duplicated schedules. Note: This query will return even though the request was submitted using a different responsibility.

SELECT request_id,user_name, NAME, argument_text FROM (SELECT cr.request_id, DECODE (cp.user_concurrent_program_name, 'Report Set', 'Report Set:' || cr.description,

cp.user_concurrent_program_name ) NAME, argument_text, fu.user_name FROM apps.fnd_concurrent_programs_tl cp, apps.fnd_concurrent_requests cr, apps.fnd_user fu WHERE cp.application_id = cr.program_application_id AND cp.concurrent_program_id = cr.concurrent_program_id AND cr.requested_by = fu.user_id AND cr.phase_code = 'P' AND cr.requested_start_date > SYSDATE AND cp.LANGUAGE = 'US' AND fu.user_name NOT LIKE 'PPG%') t1 WHERE EXISTS ( SELECT 1 FROM (SELECT cr.request_id, DECODE (cp.user_concurrent_program_name, 'Report Set', 'Report Set:' || cr.description, cp.user_concurrent_program_name ) NAME, argument_text, fu.user_name FROM apps.fnd_concurrent_programs_tl cp, apps.fnd_concurrent_requests cr, apps.fnd_user fu WHERE cp.application_id = cr.program_application_id AND cp.concurrent_program_id = cr.concurrent_program_id AND cr.requested_by = fu.user_id --AND cr.phase_code in ('P','R') AND cr.phase_code in ('P') --AND cr.requested_start_date > SYSDATE AND trunc(cr.requested_start_date) = trunc(SYSDATE) AND cp.LANGUAGE = 'US' AND fu.user_name LIKE '05%') t2 WHERE t1.NAME = t2.NAME AND t1.argument_text = t2.argument_text AND t1.user_name = t2.user_name GROUP BY NAME, argument_text, user_name HAVING COUNT (*) > 1) ORDER BY user_name, NAME,ARGUMENT_TEXT;

Average pending time per request

This is a very useful query to check the performance of the concurrent managers. Average pending time for a request is calculated like below: ("Highest of Requested_start_date or Date_submitted" - Actual_start_date ) / Total requests A Request can be in Pending state for variety of reasons like conflict with other requests, improperly tuned managers (sleep seconds / cache size / number of managers etc)

We can schedule this script to gather data regularly for historical analysis as we normally purge the concurrent requests regularly.
SELECT TO_CHAR (actual_start_date, 'DD-MON-YYYY') DAY, concurrent_queue_name, (SUM ( ( actual_start_date - (CASE WHEN requested_start_date > request_date THEN requested_start_date ELSE request_date END ) ) * 24 * 60 * 60 ) ) / COUNT (*) "Wait_Time_per_Req_in_Secs" FROM apps.fnd_concurrent_requests cr, apps.fnd_concurrent_processes fcp, apps.fnd_concurrent_queues fcq WHERE cr.phase_code = 'C' AND cr.actual_start_date IS NOT NULL AND cr.requested_start_date IS NOT NULL AND cr.controlling_manager = fcp.concurrent_process_id AND fcp.queue_application_id = fcq.application_id AND fcp.concurrent_queue_id = fcq.concurrent_queue_id GROUP BY TO_CHAR (actual_start_date, 'DD-MON-YYYY'), concurrent_queue_name ORDER BY 2

Note: Depending on the purging schedules some requests might miss if the corresponding data in fnd_concurrent_processes is purged.

Checking which manager is going to execute a program

The below query identifies the manager which will be executing a given program. This query is based on the specialization rules set for the managers.
SELECT user_concurrent_program_name, user_concurrent_queue_name FROM apps.fnd_concurrent_programs_tl cp, apps.fnd_concurrent_queue_content cqc, apps.fnd_concurrent_queues_tl cq WHERE cqc.type_application_id(+) = cp.application_id AND cqc.type_id(+) = cp.concurrent_program_id AND cqc.type_code(+) = 'P' AND cqc.include_flag(+) = 'I' AND cp.LANGUAGE = 'US' AND cp.user_concurrent_program_name = '&USER_CONCURRENT_PROGRAM_NAME' AND NVL (cqc.concurrent_queue_id, 0) = cq.concurrent_queue_id AND NVL (cqc.queue_application_id, 0) = cq.application_id AND cq.LANGUAGE = 'US'

To see all the pending / Running requests per each manager wise
SELECT request_id, phase_code, status_code, user_name, user_concurrent_queue_name FROM apps.fnd_concurrent_worker_requests cwr, apps.fnd_concurrent_queues_tl cq, apps.fnd_user fu WHERE (cwr.phase_code = 'P' OR cwr.phase_code = 'R') AND cwr.hold_flag != 'Y' AND cwr.requested_start_date <= SYSDATE AND cwr.concurrent_queue_id = cq.concurrent_queue_id AND cwr.queue_application_id = cq.application_id AND cq.LANGUAGE = 'US' AND cwr.requested_by = fu.user_id ORDER BY 5

Note: The same information can be seen in Administer Concurrent Manager form for each manager.

Checking the incompatibilities between the programs

The below query can be used to find all incompatibilities in an application instance.
SELECT a2.application_name, a1.user_concurrent_program_name, DECODE (running_type, 'P', 'Program', 'S', 'Request set', 'UNKNOWN' ) "Type", b2.application_name "Incompatible App", b1.user_concurrent_program_name "Incompatible_Prog", DECODE (to_run_type, 'P', 'Program', 'S', 'Request set', 'UNKNOWN' ) incompatible_type FROM apps.fnd_concurrent_program_serial cps, apps.fnd_concurrent_programs_tl a1, apps.fnd_concurrent_programs_tl b1, apps.fnd_application_tl a2, apps.fnd_application_tl b2 WHERE a1.application_id = cps.running_application_id AND a1.concurrent_program_id = cps.running_concurrent_program_id AND a2.application_id = cps.running_application_id AND b1.application_id = cps.to_run_application_id AND b1.concurrent_program_id = cps.to_run_concurrent_program_id AND b2.application_id = cps.to_run_application_id AND a1.language = 'US' AND a2.language = 'US' AND b1.language = 'US' AND b2.language = 'US'

Concurrent Manager and program related scripts

SQL Script to Troubleshoot a long-running concurrent request set term on set feedback on set echo on set arraysize 4 set linesize 200 set pages 9999 set underline =; column username format A15 column sid format 9990 heading SID column type format A4 column lmode format 990 heading 'HELD' column request format 990 heading 'REQ' column id1 format 9999990 column id2 format 9999990 column sql_text format a100 column name format a80 break on id1 skip 1 dup undefine v_request_id define v_request_id undefine v_spid define v_spid undefine v_sid define v_sid spool vj_concurrent_monitor.lst Prompt Enter the concurrent_request_id Accept v_request_id prompt checking requests select oracle_process_id from fnd_concurrent_requests where request_id='&v_request_id'; Prompt Enter the operating system oracle process id for this concurrent request accept v_spid Prompt Getting the sid SELECT SID,SERIAL#,LOGON_TIME FROM V$SESSION WHERE PADDR IN (SELECT ADDR FROM V$PROCESS WHERE SPID='&v_spid'); prompt Enter the session id for this concurrent request accept v_sid prompt memory usage for this session

SELECT A.SID,A.USERNAME,B.VALUE,c.name FROM V$SESSION a,V$SESSTAT B,V$STATNAME C WHERE A.SID=B.SID AND B.STATISTIC#=C.STATISTIC# AND C.NAME like'%memor%' and a.sid='&v_sid'; prompt resource usage for this session SELECT A.SID,A.USERNAME,B.VALUE,c.name FROM V$SESSION a,V$SESSTAT B,V$STATNAME C WHERE A.SID=B.SID AND B.STATISTIC#=C.STATISTIC# and a.sid='&v_sid' order by b.value; prompt this session waited on select sid,event,wait_time,state from v$session_wait where sid='&v_sid' order by wait_time; prompt current sql executing by this session select a.sid,b.sorts,b.executions,b.loads,b.parse_calls,b.disk_reads, b.buffer_gets,b.rows_processed,C.sql_text from v$session a,v$sqlarea b,V$SQLTEXT C where a.sql_address=b.address and b.address=c.address and a.sid='&v_sid'; prompt sql which is taking more than 3mb in shared pool prompt nosql should take morethan 1mb in shared pool. prompt please ask the developers to tune the following sql statements select name, namespace,type,sharable_mem/(1024*1024) sharablemem,loads,executions,locks,pins,kept from v$db_object_cache where SHARABLE_MEM>3000000; prompt sort segments using by this session SELECT s.username,s.sid,s.osuser,s.process,s.machine,u.extents, u.blocks,u.tablespace FROM v$session s, v$sort_usage u WHERE s.saddr=u.session_addr order by extents; and s.sid='&v_sid'; prompt current temp segments free in this instance SELECT tablespace_name, extent_size, total_extents, used_extents, free_extents, max_used_size FROM v$sort_segment;

prompt total system events at this time select event,total_waits waits, total_timeouts timeouts, time_waited total_time from v$system_event order by total_waits;

prompt latch contention if thery is any SELECT latch#, name, gets, misses, sleeps FROM v$latch WHERE sleeps>0 ORDER BY sleeps ; prompt the latch which is sleeping select name, sleeps,latch# from v$latch_children where sleeps>4 order by sleeps; spool off clear columns clear breaks How to find out which request is handle by which concurrent queue. a) First find out short_name of a program and then pass it as parameter to below query. b) The below query will give you output I - Included - Included in new concurrent queue E - excluded from Standard Manager This way you know now this running program (concurrent request) is handled by new manager and not part of standard manager. SELECT A.INCLUDE_FLAG, A.QUEUE_APPLICATION_ID, C.USER_CONCURRENT_QUEUE_NAME, B.CONCURRENT_PROGRAM_NAME FROM APPLSYS.FND_CONCURRENT_QUEUE_CONTENT A, APPLSYS.FND_CONCURRENT_PROGRAMS B, APPS.FND_CONCURRENT_QUEUES_VL C WHERE type_id = b.concurrent_program_id and b.concurrent_program_name = &SHORT_NAME and c.concurrent_queue_id = a.concurrent_queue_id How to find out Summary of Concurrent requests. SELECT request_id, SUBSTR(requestor,1,25), SUBSTR(program,1,50), SUBSTR(user_concurrent_program_name,1,100), TO_CHAR(actual_start_date,dd/mm/yy :hh24:mi) start_date, TO_CHAR(actual_completion_date,dd/mm/yy :hh24:mi) completion_date, FLOOR((ACTUAL_COMPLETION_DATE- ACTUAL_START_DATE)*24) in Hours, (((ACTUAL_COMPLETION_DATE- ACTUAL_START_DATE)*24)(FLOOR((ACTUAL_COMPLETION_DATE- ACTUAL_START_DATE)*24)))*60 In_Min

requestor, program, user_concurrent_program_name FROM fnd_conc_req_summary_v WHERE (ACTUAL_COMPLETION_DATE- ACTUAL_START_DATE)*24*60 >10 How to find database SID from a Concurrent request. column process heading FNDLIBR PID SELECT a.request_id, d.sid, d.serial# ,d.osuser,d.process , c.SPID FROM apps.fnd_concurrent_requests a, apps.fnd_concurrent_processes b, v$process c, v$session d WHERE a.controlling_manager = b.concurrent_process_id AND c.pid = b.oracle_process_id AND b.session_id=d.audsid AND a.request_id = &Request_ID AND a.phase_code = R; You need your concurrent request ID as an input. c.SPID= is the operating system process id d.sid= is the Oracle process id Cancel Concurrent requests. We don't need concurrent requests which are scheduled in production to keep running in test. We use the following update to cancel them. update fnd_concurrent_requests set phase_code='C', status_code='D' where phase_code = 'P' and concurrent_program_id not in ( select concurrent_program_id from fnd_concurrent_programs_tl where user_concurrent_program_name like '%Synchronize%tables%' or user_concurrent_program_name like '%Workflow%Back%' or user_concurrent_program_name like '%Sync%responsibility%role%' or user_concurrent_program_name like '%Workflow%Directory%') and (status_code = 'I' OR status_code = 'Q'); Use the SQL below to only cancel the running requests connecting as sys UPDATE applsys.fnd_concurrent_requests SET phase_code = 'C', status_code = 'X' WHERE phase_code = 'R' and status_code ='R' / commit Also, please put all Pending Jobs on Hold, using the SQL below connecting as sys

update applsys.fnd_concurrent_requests set hold_flag='Y' where phase_code='P' and hold_flag='N' / commit update fnd_concurrent_requests fcr set phase_code = 'C', status_code = 'D' where fcr.PHASE_CODE <> 'C' and (fcr.program_application_id,fcr.CONCURRENT_PROGRAM_id) in (select fcp.application_id,fcp.concurrent_program_id from fnd_concurrent_programs fcp,fnd_executables_vl fev where fcp.executable_application_id=fev.application_id and fcp.executable_id=fev.executable_id and (upper(fev.user_executable_name) like 'AL%MAIL%' or upper(fev.user_executable_name) like 'AL%FTP%' or upper(fev.user_executable_name) like 'AL%EXCEL%')) / To change the number of processes for the standard manager update FND_CONCURRENT_QUEUE_SIZE set min_processes = 4 where concurrent_queue_id = 0; how to find params passed to request from backend select CONCURRENT_PROGRAM_ID,CONCURRENT_PROGRAM_NAME from fnd_concurrent_programs where concurrent_program_name like ''; select REQUEST_ID,CONCURRENT_PROGRAM_ID,substr(ARGUMENT_TEXT,1,60)para ms,status_code,phase_code from fnd_concurrent_requests where CONCURRENT_PROGRAM_ID=; To increase the jvm for OPP "From Note ID 737311.1 we need to do step 3 We are changing this parameter to 2048m as mentioned below in script. Configure the Output Post Processor's JVM. These steps set the JVM to 2GB, depending upon your server's size you might find 3 GB (-mx3072m), 4GB (-mx4096m) or even 5GB (mx5120m) is a better value. This setting prevents the error ""java.lang.OutOfMemoryError: Java heap space"" in the Output Post Processor's log associated to the Subledger Accounting Program. Login to SQL*Plus as APPS.

SQL>update FND_CP_SERVICES set DEVELOPER_PARAMETERS = 'J:oracle.apps.fnd.cp.gsf.GSMServiceController:-mx2048m' where SERVICE_ID = (select MANAGER_TYPE from FND_CONCURRENT_QUEUES where CONCURRENT_QUEUE_NAME = 'FNDCPOPP'); Bounce the concurrent managers. one more eg: To determine current heap size: select DEVELOPER_PARAMETERS from FND_CP_SERVICES where SERVICE_ID = (select MANAGER_TYPE from FND_CONCURRENT_QUEUES where CONCURRENT_QUEUE_NAME = 'FNDCPOPP'); To increase heap size to 1024: update FND_CP_SERVICES set DEVELOPER_PARAMETERS = 'J:oracle.apps.fnd.cp.gsf.GSMServiceController:mx1024m' where SERVICE_ID = (select MANAGER_TYPE from FND_CONCURRENT_QUEUES where CONCURRENT_QUEUE_NAME = 'FNDCPOPP'); Query to find pending concurrent requests select count(*) from APPS.FND_ CONCURRENT_PROGRAMS_VL a, APPS.FND_CONCURRENT_REQUESTS b where a.CONCURRENT_PROGRAM_ID = b.CONCURRENT_PROGRAM_ID and a.APPLICATION_ID = b.PROGRAM_APPLICATION_ID and b.PHASE_CODE = 'P' and b.requested_start_date <= sysdate Pending job details "SELECT c.user_name, request_id, phase_code, status_code, hold_flag, TO_CHAR(requested_start_date,'DD-MON-YY:HH24:MM:SS') Requested_Start_Date, user_concurrent_program_name, b.concurrent_program_id FROM applsys.fnd_concurrent_requests a, applsys.fnd_concurrent_programs_tl b, applsys.fnd_user c WHERE a.phase_code = 'P' AND a.concurrent_program_id = b.concurrent_program_id AND b.LANGUAGE = 'US' AND c.user_id = a.requested_by ORDER BY user_concurrent_program_name;"

Cancel scheduled concurrent Request Gather Schema Statistics sqlplus apps/apps sql> update fnd_concurrent_requests set phase_code='C',status_code='D' WHERE phase_code = 'P' AND status_code in ('Q','I') and concurrent_program_id=38121; Commit; Exit Putting all concurrent jobs on hold: Update applsys.fnd_concurrent_requests set hold_flag='Y' where phase_code in ('R','P','I'); Cancel scheduled concurrent Request Gather Schema Statistics sqlplus apps/apps sql> update fnd_concurrent_requests set phase_code='C',status_code='D' WHERE phase_code = 'P' AND status_code in ('Q','I') and concurrent_program_id=38121; Commit; Exit To terminate request from backend SQL> select REQUEST_ID,ORACLE_ID,ORACLE_PROCESS_ID,ORACLE_SESSION_ID,OS_P ROCESS_ID from applsys.FND_CONCURRENT_REQUESTS where REQUEST_ID=577945; REQUEST_ID ORACLE_ID ORACLE_PROCESS_ID ORACLE_SESSION_ID ---------- ---------- ------------------------------ ----------------OS_PROCESS_ID ----------------------------------------------------------------------------------------------------------------------------------577945 900 13348 1242142 13299 SQL> !kill -9 13348 /bin/ksh: kill: 13348: No such process SQL> update APPLSYS.fnd_Concurrent_requests set PHASE_CODE='C', STATUS_CODE='D' where REQUEST_ID=577945;

1 row updated. SQL> commit; Commit complete. Schedule Purge Concurrent Request and/or Manager Data Cancel existing scheduled request before scheduling new. # ebappsenv # sqlplus apps update fnd_concurrent_requests set phase_code='C',status_code='D' WHERE phase_code = 'P' AND status_code in ('Q','I') and concurrent_program_id=32263; Parameter: Entity : REQUEST Mode : Age Mode Value : 15 On non-prod environments as per case# 734780 Schedule: on specific days : Wednesday and Saturday at 19:00 CET Run Gather Schema Statistics as a Concurrent request Cancel any pending jobs for Gather Schema Statistics Sqlplus apps/appspasswd Sql> update fnd_concurrent_requests set phase_code='C',status_code='D' WHERE phase_code = 'P' AND status_code in ('Q','I') and concurrent_program_id=38121; Login to Oracle applications of target instance as sysadmin thru Appjump Select system administrator Responisibility Verify whether Concurrent Request Gather Schema Statistics is running or not If not running, schedule the request to run immediately with Parameters : ALL,10 To check status fo running requests: column REQUEST heading 'Request' format a8 column PHASE heading 'Phase' format A8 column STATUS heading 'Status' format A8 column PROGRAM heading 'Program Name' format A40

column SHORT heading 'Short Name' format A15 column REQUESTOR heading 'Requestor' format A10 column START_TIME heading 'Start Time' format A15 column RUN_TIME justify left heading 'Time(m)' format 999999.9 column OSPID heading 'OSPID' format a5 column OS_PIDa heading 'OSPIDA' format a6 column SID heading 'SID' format 99999 column serial# heading 'Serial#' format 99999 select substr(fcrv.request_id,1,8)REQUEST, decode(fcrv.phase_code,'P','Pending','R','Running','I','Inactive','Completed')PHASE, decode(fcrv.status_code, 'A','Waiting', 'B','Resuming', 'C','Normal', 'F','Scheduled', 'G','Warning', 'H','On Hold', 'I','Normal', 'M','No Manager', 'Q','Standby', 'R','Normal', 'S','Suspended', 'T','Terminating', 'U','Disabled', 'W','Paused', 'X','Terminated', 'Z','Waiting',fcrv.status_code)STATUS, substr(fcrv.program,1,40)PROGRAM,substr(fcrv.PROGRAM_SHORT_NAME,1,15)SH ORT, substr(fcrv.requestor,1,15)REQUESTOR, -- to_char(fcrv.actual_start_date,'MM/DD/RR HH24:MI')START_TIME, round(((sysdate - fcrv.actual_start_date)*1440),1)RUN_TIME, substr(fcr.oracle_process_id,1,7)OSPID,s.sid,s.serial# from apps.fnd_conc_req_summary_v fcrv, apps.fnd_concurrent_requests fcr, v$session s,v$process p where fcrv.phase_code = 'R' and fcrv.request_id = fcr.request_id and s.paddr = p.addr and fcr.oracle_process_id = p.spid and fcrv.concurrent_program_id not in ('40112','40113','36887') --and trunc(fcrv.actual_start_date) like trunc(sysdate) order by PHASE, STATUS, REQUEST desc; Take export dump of concurrent tables and import

exp userid=applsys/xxxx file=conc.dmp log=exp.log tables=FND_CONCURRENT_QUEUES,FND_CONCURRENT_QUEUES_TL, FND_CONCURRENT_QUEUE_SIZE, FND_CONCURRENT_QUEUE_CONTENT Truncate the fnd concurrent tables SQL> truncate table fnd_Concurrent_queues; Table truncated. SQL> truncate table FND_CONCURRENT_QUEUES_TL; Table truncated. SQL> truncate table FND_CONCURRENT_QUEUE_SIZE; Table truncated. SQL> truncate table FND_CONCURRENT_QUEUE_CONTENT; Table truncated. Import the data back into the fnd tables which was exported as part of step above imp userid=applsys/apps ignore=y file=conc.dmp full=y log=imp.log Check whether the GSM is Up and Running in the system --> Profile option or using the Following Query : select DECODE(b.profile_option_value, 'Y', 'Enabled', 'Disabled') DETAILS from fnd_profile_options a, fnd_profile_option_values b where a.APPLICATION_ID = b.APPLICATION_ID and a.PROFILE_OPTION_ID = b.PROFILE_OPTION_ID and a.PROFILE_OPTION_NAME = 'CONC_GSM_ENABLED'; Check whether the Service Manager is up and Running by the following Query : select CONCURRENT_QUEUE_NAME, ENABLED_FLAG, MAX_PROCESSES, RUNNING_PROCESSES from FND_CONCURRENT_QUEUES where CONCURRENT_QUEUE_NAME like 'FNDSM%'; The following SQL scripts located under $FND_TOP/sql are useful when diagnosing concurrent manager problems: afimchk.sql Tells the status of the ICM and PMON method

afcmstat.sql Lists active manager processes afrqrun.sql Lists all the running, waiting and Terminating requests afrqwait.sql Lists requests that are constrained and waiting for the ICM to release them. afrqscm.sql Prints log file name of managers that can run a given request. It can be used to check for possible errors when a request stays in pending status. It requires a request id value. afcmcreq.sql Prints the log file name of the manager that processed the request afrqstat.sql Summary of completed concurrent requests grouped by completion status and execution type. It requires number of days prior to today on which to report parameter. afimlock.sql Lists locks that the ICM is waiting to get afcmrrq.sql Lists managers that currently are running a request Reports on requests that having been running for over a specified amount of time (hard coded as 4 hours). Exceptions, in addition to the defaults below, can be added by entering the program ID for the program exceptions under multi-items. Runs Every 20 minutes Uses the following query: select b.REQUEST_ID, a.DESCRIPTION, b.phase_code, (sysdate - b.actual_start_date) * 24 "running", to_char(sysdate, 'mm/dd/yyyy hh:mi') "now", to_char(b.request_date, 'mm/dd/yyyy hh:mi') "request_date", to_char(b.actual_start_date, 'mm/dd/yyyy hh:mi') "start_time", b.program_application_id "program_application_id", b.concurrent_program_id "concurrent_program_id" from APPS.FND_CONCURRENT_PROGRAMS_VL a, APPS.FND_CONCURRENT_REQUESTS b where a.CONCURRENT_PROGRAM_ID = b.CONCURRENT_PROGRAM_ID and a.APPLICATION_ID = b.PROGRAM_APPLICATION_ID and b.STATUS_CODE = 'R' and b.PHASE_CODE = 'R' and ((sysdate - b.actual_start_date) * 24) > 4 and a.CONCURRENT_PROGRAM_ID NOT IN(36887,43393,38121,42789,31556) Excludes: 36887 - Workflow Mailer

43393 - ITM Adapter 38121 - Gather Schema Statistics 42789 - OAM Applications Dashboard Collection 31556 - Planning Manager Monitors pending jobs exceeds the specified threshold. Excessive pending jobs may indicate an issue with the Concurrent Manager. Uses the following query: select a.concurrent_program_name, b.REQUEST_ID, a.description, to_char(b.request_date, 'mm/dd/yyyy hh:mi:ss') ""request_date"", to_char(b.requested_start_date, 'mm/dd/yyyy hh:mi:ss') ""request_start"" from APPS.FND_CONCURRENT_PROGRAMS_VL a, APPS.FND_CONCURRENT_REQUESTS b where a.CONCURRENT_PROGRAM_ID = b.CONCURRENT_PROGRAM_ID and a.APPLICATION_ID = b.PROGRAM_APPLICATION_ID and b.PHASE_CODE = 'P' and b.requested_start_date <= sysdate The error threshold monitor will alert if the number of failed jobs exceeds the user defined threshold in a 30 minute period. select a.concurrent_program_name, b.REQUEST_ID, a.description, b.status_code, b.phase_code from APPS.FND_CONCURRENT_PROGRAMS_VL a, APPS.FND_CONCURRENT_REQUESTS b where a.CONCURRENT_PROGRAM_ID = b.CONCURRENT_PROGRAM_ID and a.APPLICATION_ID = b.PROGRAM_APPLICATION_ID and b.STATUS_CODE IN ('E') and b.actual_completion_date > sysdate - 1/48 Find request which are put on hold SQL> select REQUEST_ID from fnd_concurrent_requests where phase_code ='P' and hold_flag='Y'; To find oracle_process id for a request id to pull trace file from udump: select oracle_process_id , decode(status_code,'R','Running','D','Canceled','E','Error','X','Terminated','G','Warning','T' ,'Terminating')""Status_code"", phase_code,to_char(actual_start_date,'DD-MON-YYYY=>hh24:mi:ss') ""Login Time"" from apps.fnd_concurrent_requests where request_id='&Enter_conn_req_id'

To find spid of a request to get the trace file prompt accept request prompt 'Please enter the concurrent request id for the appropriate concurrent program: prompt column traceid format a8 column tracename format a80 column user_concurrent_program_name format a40 column execname format a15 column enable_trace format a12 set lines 80 set pages 22 set head off SELECT 'Request id: '||request_id ,'Trace id: '||oracle_Process_id, 'Trace Flag: '|| req.enable_trace, 'Trace Name:'||dest.value||'/'||lower(dbnm.value)||'_ora_'||oracle_process_id||'.trc', 'Prog. Name: '||prog.user_concurrent_program_name,'File Name: '|| execname.execution_file_name|| execname.subroutine_name , 'Status : '||decode(phase_code,'R','Running') ||'-'||decode(status_code,'R','Normal'),'SID Serial: '||ses.sid||','|| ses.serial#,'Module : '||ses.module from fnd_concurrent_requests req, v$session ses, v$process proc, v$parameter dest, v$parameter dbnm, fnd_concurrent_programs_vl prog, fnd_executables execname where req.request_id ='&request' and req.oracle_process_id=proc.spid(+) and proc.addr = ses.paddr(+) and dest.name='user_dump_dest' and dbnm.name='db_name' and req.concurrent_program_id = prog.concurrent_program_id and req.program_application_id = prog.application_id and prog.application_id = execname.application_id and prog.executable_id=execname.executable_id To check failed jobs submitted by an user set lines 1000 pages 100 clear columns col "Submitted By" format a15 word_wrap select user_name "Submitted By", request_id "Request #", to_char(cr.request_date,'dd-mon-rr hh24:mi') "Submitted on", to_char(cr.last_update_date,'dd-mon-rr hh24:mi') "Failed on" from applsys.fnd_concurrent_requests cr, applsys.fnd_user u where u.user_id = cr.requested_by and user_name like '%BATCH%'

and cr.status_code ='E' and cr.phase_code ='C' and cr.request_date > sysdate - 1 order by 1 Statement to put the jobs on hold and release them lateron To hold the requests (as apps user): 1) Drop table apps.str_dba_conc_req_hold ; 2) Create table apps.str_dba_conc_req_hold as select * from fnd_Concurrent_requests where PHASE_CODE='P' and hold_flag='N'; 3) select count(*) from apps.str_dba_conc_req_hold ; 4) update fnd_Concurrent_requests set hold_flag='Y' where PHASE_CODE='P' and hold_flag='N' and request_id in (select request_id from apps.str_dba_conc_req_hold) ; NOTE: You have to commit if select & update are same number of records. Otherwise rollback and try again till the numbers are same 5) Commit; To Release these requests in prod after patching, here is the step : 6) a. update fnd_Concurrent_requests set hold_flag='N' where request_id in (select request_id from apps.str_dba_conc_req_hold); b. commit; How to take cm program trace. Responsibility: System Administrator Navigate: Concurrent > Program > Define Query Concurrent Program Select the Enable Trace Checkbox Responsibility: System Administrator Navigate: Profiles > System Query Profile Option Concurrent: Allow Debugging Set profile to Yes Logon to the Responsibility that runs the Concurrent Program In the Submit Request Screen click on Debug Options (B) Select the Checkbox for SQL Trace To submit active user request from backend CONCSUB APPS/APPS SYSADMIN "System Administrator" SYSADMIN CONCURRENT FND FNDSCURS PROGRAM_NAME='"Active Users"'

sql program to submit request from backend "SET SERVEROUTPUT ON declare req_id number; begin DBMS_OUTPUT.PUT_LINE('In begin'); fnd_global.APPS_INITIALIZE (0, 21758, 671); req_id := FND_REQUEST.SUBMIT_REQUEST(application => 'FND',program => 'FNDSCURS',description => '',start_time => '',sub_request => FALSE); if (req_id = 0) then /* Handle submission error */ DBMS_OUTPUT.PUT_LINE('Request ID :' || req_id); DBMS_OUTPUT.PUT_LINE('As the request ID is 0, the request was not submitted'); DBMS_OUTPUT.PUT_LINE('Please verify this part again'); else DBMS_OUTPUT.PUT_LINE('Request ID :' || req_id); DBMS_OUTPUT.PUT_LINE('Request submitted successfully'); commit; end if; end; / Meaning of status_code and phase_code in FND_CONCURRENT_REQUESTS table STATUS_CODE Column: A - Waiting B - Resuming C - Normal D - Cancelled E - Error F - Scheduled G - Warning H - On Hold I - Normal M - No Manager Q - Standby R - Normal S - Suspended T - Terminating U - Disabled W - Paused X - Terminated Z - Waiting

PHASE_CODE column C - Completed I - Inactive P - Pending R - Running

select prog.user_concurrent_program_name "program name", prog.concurrent_program_name "program short name", appl.application_name "program application name", prog.description "program description", exe.executable_name "executable name", exe.execution_file_name "executable file name" --exe.description "executable description" --decode( exe.execution_method_code, 'I', 'PLSQL Stored Procedure', 'P', 'Report', 'L', 'SQL Loader', exe.execution_method_code) "execution method" from apps.fnd_executables exe, apps.fnd_application_tl appl, apps.fnd_concurrent_programs_vl prog where prog.application_id = appl.application_id AND exe.executable_id = prog.executable_id --AND prog.user_concurrent_program_name = --AND prog.concurrent_program_name = --AND exe.execution_file_name = AND exe.execution_method_code = 'P' and prog.USER_CONCURRENT_PROGRAM_NAME LIKE '05%ONT%' and nvl(prog.enabled_flag,'N') = 'Y' ORDER BY 1

select B.* from fnd_concurrent_programs a, fnd_concurrent_programs_tl b where 1=1 and a.concurrent_program_id = b.concurrent_program_id and USER_CONCURRENT_PROGRAM_NAME like '05%ONT%' and a.enabled_flag = 'Y' and execution_method_code ='P'