Microsoft Technology Licensing, LLC

Salesforce Com, Inc.

Gregory Darrell Fee

Loren Kohnfelder

Brian LaMacchia

William John Gallagher

Sebastian Lange

Christopher Wellington Brumme

Michael Joseph Toutonghi

Jeffrey M Cooperstein

Aaron Ross Goldfeder

Erik B Christensen

Anders Hejlsberg

Gopala Krishna R Kakivaya

Michael M Magruder

Raja Krishnaswamy

David Bau

Lance Olson

Henry L Sanders

David S Ebbo

Blair Brewster Dillaway

Julie D Bennett

James S Miller

Travis Muhlestein

Sean Edwin Trowbridge

Jonathan C Hawkins

Krzysztof J Cwalina

Seth Mitchell Demsey

Brian M Grunkemeyer

Shawn Patrick Burke

Christopher L Anderson

Stefan Harrington Pharies

Yung-Shin Lin

Anthony J Moore

Erik B Olson

Yann Christensen

Fabio A Yeon

John M Hawkins

James H Hogg

Craig T Sinclair

Adam Wade Smith

Corina Eva Feuerstein

David S Mortenson

Caleb L Doise

Alan Geoffrey Boshier

Shajan Dasan

Manish S Prabhu

Radu Rares Palanca

Joseph L Roxe

John I McConnell

Tarun Anand

Suzanne Maurine Cook

Ramasamy Krishnaswamy

Hany E Ramadan

Jesus Ruiz-Scougall

Joe Dennis Long

Jayanth V Rajan

Daniel Takacs

Brian Irl Pratt

Sreeram Duvur

Mahesh Prakriya

Moritz Y Becker

Jason Forrest Mackay

Christopher Wall

David Owen Driver

John Michael Leen

Yan Valerie Leshinsky

Stephen James Millet

Giovanni Moises Della-Libera

Nikhil Kothari

Vance Palmer Morrison

Scott David Guthrie

Tony Edward Schreiner

Luca Bolognese

Venkatraman V Kudallur

Keith W Ballinger

Brian Keith Pepin

Mark T Anders

James Bock Wunderlich

Jun Fang

Jingyang Xu

Susan M Warren

Nicholas M Kramer

Manu Vasandani

Robert Michael Howard

Forrest Junod

Nicholas Chun Yuan Chen

Viresh Ramdatmisier

Jeremiah S Epling

Chad W Royal

Ivan Medvedev

Mark W Fussell

Sreeram Nivarthi

Mark A Boulter

Omri Gazitt

Izydor Gryko

Andrew G Bybee

Nithyalakshmi Sampathkumar

Stephanie Sweeny Saad

Neetu Rajpal

Simon Jeremy Hall

Daniel Dedu-Constantin

Techniques and mechanisms for providing asynchronous web service calls in an on-demand services environment. In response to request from a remote client, a page is provided. The page has content including logic to retrieve information from a remote resource external to an on-demand services environment via at least one asynchronous web service call. A controller component of the page is loaded before rendering a response to the remote computing device. At least one web service call is sent to the remote resource with the controller component. A continuation object is returned with the controller component to release the first thread from waiting for a response to the web service call. The continuation object provides a label to be used when handling the response. The response to the web service call is received from the remote resource and processing is resumed with the continuation object.

Asynchronous web service callouts and servlet handling

Techniques and mechanisms for conversion of code of a first type to bytecode. Apex provides various unique characteristics. When converting to bytecode, these characteristics are handled to provide bytecode functionality. Some of the unique characteristics of Apex include Autoboxing, SOQL, Properties, Comparisons, Modifiers, Code coverage mechanisms and Sharing mechanisms.

Methods and systems for evaluating bytecode in an on-demand service environment including translation of apex to bytecode

The technology disclosed describes systems and methods for implementing global profiling to track resource usage and performance for multiple threads across multiple servers for a cloud-based system. This disclosed technology provides global profiling to track resource usage across any part of a transaction as it passes between layers of a computing stack regardless of the language being executed, on logically different virtual machines across multiple servers. After data collection stops, the disclosed technology combines the results into a configurable profile view that accurately represents the order of execution of applications and methods, as though they ran on one machine. The disclosed technology builds multiple formats of the data files for different display visualizations.

Systems and methods of implementing tracking of resource usage for a cloud-based system

In accordance with embodiments disclosed herein, there are provided mechanisms and methods for batch processing in an on-demand service environment. For example, in one embodiment, mechanisms include receiving a processing request for a multi-tenant database, in which the processing request specifies processing logic and a processing target group within the multi-tenant database. Such an embodiment further includes dividing or chunking the processing target group into a plurality of processing target sub-groups, queuing the processing request with a batch processing queue for the multi-tenant database among a plurality of previously queued processing requests, and releasing each of the plurality of processing target sub-groups for processing in the multi-tenant database via the processing logic at one or more times specified by the batch processing queue.

Methods and systems for batch processing in an on-demand service environment

Execution of code in a multitenant runtime environment. A request to execute code corresponding to a tenant identifier (ID) is received in a multitenant environment. The multitenant database stores data for multiple client entities each identified by a tenant ID having one of one or more users associated with the tenant ID. Users of each of multiple client entities can only access data identified by a tenant ID associated with the respective client entity. The multitenant database is a hosted database provided by an entity separate from the client entities, and provides on-demand database service to the client entities. Source code corresponding to the code to be executed is retrieved from a multitenant database. The retrieved source code is compiled. The compiled code is executed in the multitenant runtime environment. The memory used by the compiled code is freed in response to completion of the execution of the compiled code.

Methods and systems for utilizing bytecode in an on-demand service environment including providing multi-tenant runtime environments and systems

Software tools assist an access-policy analyst or creator to debug and/or author access policies. An access request contains a query that evaluates to either true or false depending on whether access is to be allowed. Abduction may be used to generate assumptions that, if true, would cause the access request to be true. The tool may perform analysis on the generated assumptions, such as: comparing the assumptions with tokens to detect errors in the tokens or to suggest changes to the tokens that would cause the query to be satisfied, or comparing the assumptions to a meta-policy. The tool may allow an analysis, policy author, or other person to interactively walk through assumptions in order to see the implications of the access policy.

Access policy analysis

Access to a resource may be controlled by a policy, such that a request to access the resource is either granted or denied based on what assertions have been made by various principals. To find the assertions that support a grant of access to the resource, a template may be created that defines the nature of assertions that would cause access to succeed. Assertions may be stored in the form of tokens. The template may be used to search an existing token store to find assertions that have been made, and/or to generate assertions that have not been found in the token store and that would satisfy the template. The assertions in the template may be created by performing an abductive reasoning process on an access query.

Delegation in logic-based access control

Access to a resource by sandboxed code is dynamically authorized by a client security system based on a resource based policy. A sandboxed application running on a client is granted access to a resource based on a resource based policy despite denial of the access based on a static policy associated with the client security system. The granting of access coincides with the determination that the threat to a user or the user's information is not increased should the access be granted.

Resource based dynamic security authorization

Described is a mechanism for collectively evaluating security risks associated with loading an application. A hosting environment associated with loading the application invokes a trust manager to evaluate the security risks. The trust manager invokes a plurality of trust evaluators, where each trust evaluator is responsible for analyzing and assessing a different security risk. Upon completion of each security risk evaluation, results of those individual security risk evaluations are returned to the trust manager. The trust manager aggregates the variety of security risk evaluation results and makes a security determination based on the aggregated evaluation results. That determination may be to move forward with loading the application, to block the load of the application, or perhaps to prompt the user for a decision about whether to move forward with the load.

Mechanism for evaluating security risks

Growing community of inventors

Seattle, WA, United States of America

Gregory Darrell Fee